# packages

pkgId: c8496361a6591d0fd9e72326fc3fb8c6724bcec0d20ac746bdcabb4faa747b27
name: python-betterconf
arch: src
version: 4.1.0
epoch: 0
release: 1
summary: Configs in Python made smooth and simple
url: https://github.com/prostomarkeloff/betterconf
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-betterconf-4.1.0-1.src.rpm
checksum_type: sha256
description:
  Betterconf (**better config**) is a Python library for project configuration
  management. It allows you define your config like a regular Python class.

  Features:

  * Easy to hack.
  * Less boilerplate.
  * Minimal code to do big things.
  * Zero dependencies. Only vanilla Python >=3.11

  Betterconf is heavily typed, so your editors and typecheckers will be happy with it.

  It's not that huge as Pydantic, so takes like 5 minutes to dive into.

  Betterconf is highly customizable, so you can do anything with it.



  I recommend you to use poetry:

  ```sh
  poetry add betterconf
  ```

  However, you can use pip:

  ```sh
  pip install betterconf
  ```



  Betterconf is very intuitive, so you don't need special knowledge to use it. We'll cover the basics.

  The most simple config will look like this:
  ```python
  from betterconf import betterconf

  @betterconf
  class Config:
      LOGIN: str
      PASSWORD: str

  cfg = Config()
  print(config.LOGIN)
  ```

  Let's dive into what it does. By default, betterconf uses `EnvironmentProvider`, getting values with `os.getenv`,
  so you can run this example with `LOGIN=vasya PASSWORD=admin python config.py` and simply get your login.


  But what if you need a different provider? Betterconf lets you set providers as for config itself and for each field respectively.

  ```python
  import json
  from betterconf import Alias
  from betterconf import betterconf, field
  from betterconf import JSONProvider, AbstractProvider

  sample_json_config = json.dumps({"field": {"from": {"json": 123}}})


  class NameProvider(AbstractProvider):
      def get(self, name: str) -> str:
          return name

  @betterconf(provider=NameProvider())
  class Config:
      
      my_fancy_name: str
      
      field_from_json: Alias[int, "field::from::json"] = field(provider=JSONProvider(sample_json_config, nested_access="::"))

  ```

  Betterconf casts primitive types itself, they include list, float, str, int. But if you need specific caster, say for complex object, you can write your own.

  ```python
  from betterconf import betterconf
  from betterconf import AbstractCaster, field

  class DashesToDotsCaster(AbstractCaster):
      def cast(self, val: str) -> str:
          return val.replace("_", ".")

  @betterconf
  class Config:
      simple_int: int
      value: str = field(caster=DashesToDotsCaster())

  print(Config(value="privet_mir", simple_int="55666").value)
  ```

  Subconfigs and referencing one field in another declaration is also available. Check out examples folder.


  This project is licensed under MIT License.

  See [LICENSE](LICENSE) for details.


  Made with :heart: by [prostomarkeloff](https://github.com/prostomarkeloff) and our contributors.


pkgId: a51ebfc05fc7df58d60fbdc114a297c9b5cc5253f2f7e01e9393ef0d67fa3ca0
name: python-betterdata
arch: src
version: 23.0.2
epoch: 0
release: 1
summary: a lib for working with data
url: https://github.com/gmankab/betterdata
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-betterdata-23.0.2-1.src.rpm
checksum_type: sha256
description:
  <img src="https://github.com/gmankab/betterdata/raw/main/img/transparent.png">

  library for working with data. Features: automatic writing to disk when new data is added to an object, quick export to yml



  - [installation](#installation)
  - [usage](#usage)
  - [reading](#reading)
  - [autosaves](#autosaves)
  - [manual saves](#manual-saves)
  - [some syntax sugar](#some-syntax-sugar)
  - [interactive input](#interactive-input)
  - [license](#license)



  ```sh
  pip install betterdata
  ```



  ```py
  from betterdata import Data

  df = Data(
      data = {
          'key1': 'val1',
          'key2': 'val2',
      },
      file_path = 'data.yml'
  )
  ```

  after running this code it will automatically create file `data.yml`

  ```yml
  key1: val1
  key2: val2
  ```

  if file already exists, then it will be overwritten



  if you will not specify `data` argument, then data will be read from disk

  ```py
  from betterdata import Data

  df = Data(
      file_path = 'data.yml'
  )

  print(df)

  ```

  if file does not exists then dict will be empty

  ```py
  from betterdata import Data
  from pathlib import Path

  Path('data.yml').unlink()

  data = Data(
      file_path = 'data.yml'
  )

  print(data)

  ```



  if you put something in the dictionary then it will also automatically written to disk

  ```py
  from betterdata import Data

  data = Data(
      file_path = 'data.yml'
  )

  print(data)

  print(Path('data.yml').exists())


  data['key1'] = 'val1'
  data['key2'] = 'val2'

  print(data)

  print(open('data.yml', 'r').read())


  ```



  if you editing list in a dict then it will not automatically saved, but you can save it manually

  ```py
  from betterdata import Data
  from pathlib import Path

  Path('data.yml').unlink(missing_ok=True)
  data = Data(
      file_path = 'data.yml'
  )

  print(data)

  print(Path('data.yml').exists())


  data['list'] = [1, 2, 3]

  print(data)

  print(open('data.yml', 'r').read())





  data['list'].append('some very important data')

  print(data)

  print(open('data.yml', 'r').read())







  data.to_file()

  print(open('data.yml', 'r').read())





  ```



  ```py
  from betterdata import Data

  data = Data(
      {
          'key1': 'val1',
          'key2': 'val2',
      }
  )

  print(data)


  print(data['key1'])


  print(data.key1)


  print(data.to_str())



  print('key2' in data)


  print('key3' in data)


  print(data['key3'])


  print(data.key3)

  ```



  ```py
  from betterdata import Data

  data = Data()

  data.interactive_input('key1')
  ```

  it will interactively ask user to input value for `key1`

  args:
  `item: str` # key name
  `digits_to_int: bool = True` # convert digits from str to int
  `kill_app_on_exit: bool = True` # kill app if user select `exit` button
  `break_if_exist: bool = True` # skip   interactive input if key already in dict
  `sel: Sel = yes_no` # you can specify Sel object from [easyselect lib](https://github.com/gmankab/easyselect) which will be used to confirm the value
  `text = None` # change text which will be printed on the screen



  [gnu gpl 3](https://gnu.org/licenses/gpl-3.0.en.html)


pkgId: 47fbdfa01e57d0af96a96910d43dcb60c1c15bf1e227697ad3a903ddf5090349
name: python-betterlogging
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: My logging improvement
url: https://github.com/vd2org/betterlogging
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-betterlogging-1.0.0-1.src.rpm
checksum_type: sha256
description:
  ![BetterLogging](https://telegra.ph/file/ebd3b272eb1969dd55f58.png "BetterLogging")

  Improved version of the standard logger.

  * Added `TRACE` level.
  * Added `ColorizedFormatter`.
  * Added better traceback formatting.

  This package patching the standard `logging` library.

  Thus, after import, all improvements will be available inside the `logging` module.

  But for better typing, I prefer to use `betterlogging` everywhere.



  Python 3.7 and above. No additional dependencies.



  `pip install betterlogging`





  ```python
  import betterlogging as logging


  logging.basic_colorized_config(level=logging.INFO)

  logger = logging.getLogger('test')

  logger.trace("some trace message")
  logger.debug("some debug message")
  logger.info("some info message")
  logger.warning("some warning message")
  logger.error("some error message")
  logger.critical("some critical message")
  ```



  ```python
  import betterlogging as logging



  logger = logging.get_colorized_logger(name="test")


  handler = logging.StreamHandler()
  handler.setFormatter(logging.ColorizedFormatter(hide_lib_diagnose=False))

  logger.addHandler(handler)
  logger.setLevel(logging.TRACE)

  logger.trace("some trace message")
  logger.debug("some debug message")
  logger.info("some info message")
  logger.warning("some warning message")
  logger.error("some error message")
  logger.critical("some critical message")

  def div(x: int, y: int) -> float:
      return x / y

  try:
      div(1, 0)
  except:
      logger.exception("Some exception")
  ```



  ```json
  {
    "version": 1,
    "disable_existing_loggers": false,
    "formatters": {
      "default": {
        "()": "betterlogging.ColorizedFormatter"
      },
      "access": {
        "()": "betterlogging.ColorizedFormatter",
        "fmt": "ss s-8ss s[s] ss"
      }
    },
    "handlers": {
      "default": {
        "formatter": "default",
        "class": "logging.StreamHandler"
      },
      "access": {
        "formatter": "access",
        "class": "logging.StreamHandler",
        "stream": "ext://sys.stdout"
      }
    },
    "loggers": {
      "": {
        "handlers": [
          "default"
        ],
        "level": "DEBUG"
      },
      "uvicorn.error": {
        "level": "INFO"
      },
      "uvicorn.access": {
        "handlers": [
          "access"
        ],
        "level": "INFO",
        "propagate": false
      }
    }
  }
  ```

  ```shell script
  uvicorn application:app --debug --reload --log-config ./logging.json
  ```


pkgId: 1f47806f8afd0eac465d3ce689007085cb3ee32528499c1a728f7f1429c99090
name: python-betterpathlib
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: A Path library that is a compatible extension to Python's built-in pathlib.Path.
url: https://github.com/tsoernes/betterpathlib
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-betterpathlib-0.1.9-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/betterpathlib.svg)](https://badge.fury.io/py/betterpathlib)
  [![ReadTheDocs](https://readthedocs.org/projects/betterpathlib/badge/?version=latest)](https://readthedocs.org/projects/betterpathlib)


  An Path library that is an extension to Pythons built-in pathlib.Path.

  ```
  pip install betterpathlib[all]
  ```

  Especially useful for dealing with:
  - paths with multiple suffixes, e.g. files of the sort `archive.tar.gz`.
  - paths with numerical suffixes, i.e. files of the sort `part.rar.001`.

  ... and in addition, adds methods for:
  - Case-insensitive globbing
  - Copying files and directories
  - Reading JSON directly from Path object
  - Downloading file from URL to destination, if the file is not already downloaded
  - Atomic writes
  - Random paths (with optional prefix and/or suffix)

  Has no external dependencies if not installed with optional features.



  - `download` - Requires `requests` and and allows for `or_download()`
  - `similarpaths` - Requires `thefuzz` and and allows for `most_similar_paths()`


pkgId: 65b60bb4638a68ce22679ef287def675f368728d3b0a77cc0200520b9de748f3
name: python-betterplotlib
arch: src
version: 1.12.9
epoch: 0
release: 1
summary: Some wrappers for matplotlib to make plotting easier and nicer.
url: https://pypi.org/project/betterplotlib/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-betterplotlib-1.12.9-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/gillenbrown/betterplotlib/actions/workflows/tests.yaml/badge.svg?branch=master)](https://github.com/gillenbrown/betterplotlib/actions/workflows/tests.yaml)
  [![Coverage Status](https://coveralls.io/repos/github/gillenbrown/betterplotlib/badge.svg?branch=master)](https://coveralls.io/github/gillenbrown/betterplotlib?branch=master)


  Some tools to help me make nicer plots

  Documentation is here: http://betterplotlib.readthedocs.org/

rpm_license:
  MIT License  Copyright (c) 2016 Gillen Brown  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: c4dc5d98ad34f9c0c651b298b26ff411beabb888b6ad384e7240fb7b991c2b1a
name: python-betterprints
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/betterprints/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-betterprints-0.1.3-1.src.rpm
checksum_type: sha256
description:
      betterprints is a python package meant to help with alternatives to the usual print() options, adding new tools to your coding arsenal.



  - debugprint(): can be turned on and off (for production environments) using the function toggleDebugMode on you config class
  - betterprint(): overall a more versatile way to print, adds styling options and type recognitions
  - styledprint(): your good old print() friend with beautiful color options!
  - classprint(): prints all user made classes attributes and instace detailing



  This package is an experimental package made from a student, it is not yet finished and need some serious upgrading, any feedback is welcome, and you can further colaborate at Github<https://github.com/gui23dib/python-better-prints>


pkgId: eb62e2df54b3694ad65d24b9b9e57e6da1601869ec0963d2e04999c1d595b285
name: python-betterproto
arch: src
version: 1.2.5
epoch: 0
release: 1
summary: A better Protobuf / gRPC generator & library
url: http://github.com/danielgtaylor/python-betterproto
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-betterproto-1.2.5-1.src.rpm
checksum_type: sha256
description:
  ![](https://github.com/danielgtaylor/python-betterproto/workflows/CI/badge.svg)

  This project aims to provide an improved experience when using Protobuf / gRPC in a modern Python environment by making use of modern language features and generating readable, understandable, idiomatic Python code. It will not support legacy features or environments (e.g. Protobuf 2). The following are supported:

  - Protobuf 3 & gRPC code generation
    - Both binary & JSON serialization is built-in
  - Python 3.6+ making use of:
    - Enums
    - Dataclasses
    - `async`/`await`
    - Timezone-aware `datetime` and `timedelta` objects
    - Relative imports
    - Mypy type checking

  This project is heavily inspired by, and borrows functionality from:

  - https://github.com/protocolbuffers/protobuf/tree/master/python
  - https://github.com/eigenein/protobuf/
  - https://github.com/vmagamedov/grpclib



  This project exists because I am unhappy with the state of the official Google protoc plugin for Python.

  - No `async` support (requires additional `grpclib` plugin)
  - No typing support or code completion/intelligence (requires additional `mypy` plugin)
  - No `__init__.py` module files get generated
  - Output is not importable
    - Import paths break in Python 3 unless you mess with `sys.path`
  - Bugs when names clash (e.g. `codecs` package)
  - Generated code is not idiomatic
    - Completely unreadable runtime code-generation
    - Much code looks like C++ or Java ported 1:1 to Python
    - Capitalized function names like `HasField()` and `SerializeToString()`
    - Uses `SerializeToString()` rather than the built-in `__bytes__()`
    - Special wrapped types don't use Python's `None`
    - Timestamp/duration types don't use Python's built-in `datetime` module

  This project is a reimplementation from the ground up focused on idiomatic modern Python to help fix some of the above. While it may not be a 1:1 drop-in replacement due to changed method names and call patterns, the wire format is identical.



  First, install the package. Note that the `[compiler]` feature flag tells it to install extra dependencies only needed by the `protoc` plugin:

  ```sh

  $ pip install "betterproto[compiler]"


  $ pip install betterproto
  ```

  Now, given you installed the compiler and have a proto file, e.g `example.proto`:

  ```protobuf
  syntax = "proto3";

  package hello;

  // Greeting represents a message you can tell a user.
  message Greeting {
    string message = 1;
  }
  ```

  You can run the following:

  ```sh
  $ protoc -I . --python_betterproto_out=. example.proto
  ```

  This will generate `hello.py` which looks like:

  ```py



  from dataclasses import dataclass

  import betterproto


  @dataclass
  class Hello(betterproto.Message):
      """Greeting represents a message you can tell a user."""

      message: str = betterproto.string_field(1)
  ```

  Now you can use it!

  ```py
  >>> from hello import Hello
  >>> test = Hello()
  >>> test
  Hello(message='')

  >>> test.message = "Hey!"
  >>> test
  Hello(message="Hey!")

  >>> serialized = bytes(test)
  >>> serialized
  b'\n\x04Hey!'

  >>> another = Hello().parse(serialized)
  >>> another
  Hello(message="Hey!")

  >>> another.to_dict()
  {"message": "Hey!"}
  >>> another.to_json(indent=2)
  '{\n  "message": "Hey!"\n}'
  ```



  The generated Protobuf `Message` classes are compatible with [grpclib](https://github.com/vmagamedov/grpclib) so you are free to use it if you like. That said, this project also includes support for async gRPC stub generation with better static type checking and code completion support. It is enabled by default.

  Given an example like:

  ```protobuf
  syntax = "proto3";

  package echo;

  message EchoRequest {
    string value = 1;
    // Number of extra times to echo
    uint32 extra_times = 2;
  }

  message EchoResponse {
    repeated string values = 1;
  }

  message EchoStreamResponse  {
    string value = 1;
  }

  service Echo {
    rpc Echo(EchoRequest) returns (EchoResponse);
    rpc EchoStream(EchoRequest) returns (stream EchoStreamResponse);
  }
  ```

  You can use it like so (enable async in the interactive shell first):

  ```py
  >>> import echo
  >>> from grpclib.client import Channel

  >>> channel = Channel(host="127.0.0.1", port=1234)
  >>> service = echo.EchoStub(channel)
  >>> await service.echo(value="hello", extra_times=1)
  EchoResponse(values=["hello", "hello"])

  >>> async for response in service.echo_stream(value="hello", extra_times=1)
          print(response)

  EchoStreamResponse(value="hello")
  EchoStreamResponse(value="hello")
  ```



  Both serializing and parsing are supported to/from JSON and Python dictionaries using the following methods:

  - Dicts: `Message().to_dict()`, `Message().from_dict(...)`
  - JSON: `Message().to_json()`, `Message().from_json(...)`

  For compatibility the default is to convert field names to `camelCase`. You can control this behavior by passing a casing value, e.g:

  ```py
  >>> MyMessage().to_dict(casing=betterproto.Casing.SNAKE)
  ```



  Sometimes it is useful to be able to determine whether a message has been sent on the wire. This is how the Google wrapper types work to let you know whether a value is unset, set as the default (zero value), or set as something else, for example.

  Use `betterproto.serialized_on_wire(message)` to determine if it was sent. This is a little bit different from the official Google generated Python code, and it lives outside the generated `Message` class to prevent name clashes. Note that it **only** supports Proto 3 and thus can **only** be used to check if `Message` fields are set. You cannot check if a scalar was sent on the wire.

  ```py

  >>> mymessage.HasField('myfield')


  >>> betterproto.serialized_on_wire(mymessage.myfield)
  ```



  Protobuf supports grouping fields in a `oneof` clause. Only one of the fields in the group may be set at a given time. For example, given the proto:

  ```protobuf
  syntax = "proto3";

  message Test {
    oneof foo {
      bool on = 1;
      int32 count = 2;
      string name = 3;
    }
  }
  ```

  You can use `betterproto.which_one_of(message, group_name)` to determine which of the fields was set. It returns a tuple of the field name and value, or a blank string and `None` if unset.

  ```py
  >>> test = Test()
  >>> betterproto.which_one_of(test, "foo")
  ["", None]

  >>> test.on = True
  >>> betterproto.which_one_of(test, "foo")
  ["on", True]


  >>> test.count = 57
  >>> betterproto.which_one_of(test, "foo")
  ["count", 57]
  >>> test.on
  False


  >>> test.name = ""
  >>> betterproto.which_one_of(test, "foo")
  ["name", ""]
  >>> test.count
  0
  >>> test.on
  False
  ```

  Again this is a little different than the official Google code generator:

  ```py

  >>> message.WhichOneof("group")
  "foo"


  >>> betterproto.which_one_of(message, "group")
  ["foo", "foo's value"]
  ```



  Google provides several well-known message types like a timestamp, duration, and several wrappers used to provide optional zero value support. Each of these has a special JSON representation and is handled a little differently from normal messages. The Python mapping for these is as follows:

  | Google Message              | Python Type                              | Default                |
  | --------------------------- | ---------------------------------------- | ---------------------- |
  | `google.protobuf.duration`  | [`datetime.timedelta`][td]               | `0`                    |
  | `google.protobuf.timestamp` | Timezone-aware [`datetime.datetime`][dt] | `1970-01-01T00:00:00Z` |
  | `google.protobuf.*Value`    | `Optional[...]`                          | `None`                 |

  [td]: https://docs.python.org/3/library/datetime.html#timedelta-objects
  [dt]: https://docs.python.org/3/library/datetime.html#datetime.datetime

  For the wrapper types, the Python type corresponds to the wrapped type, e.g. `google.protobuf.BoolValue` becomes `Optional[bool]` while `google.protobuf.Int32Value` becomes `Optional[int]`. All of the optional values default to `None`, so don't forget to check for that possible state. Given:

  ```protobuf
  syntax = "proto3";

  import "google/protobuf/duration.proto";
  import "google/protobuf/timestamp.proto";
  import "google/protobuf/wrappers.proto";

  message Test {
    google.protobuf.BoolValue maybe = 1;
    google.protobuf.Timestamp ts = 2;
    google.protobuf.Duration duration = 3;
  }
  ```

  You can do stuff like:

  ```py
  >>> t = Test().from_dict({"maybe": True, "ts": "2019-01-01T12:00:00Z", "duration": "1.200s"})
  >>> t
  Test(maybe=True, ts=datetime.datetime(2019, 1, 1, 12, 0, tzinfo=datetime.timezone.utc), duration=datetime.timedelta(seconds=1, microseconds=200000))

  >>> t.ts - t.duration
  datetime.datetime(2019, 1, 1, 11, 59, 58, 800000, tzinfo=datetime.timezone.utc)

  >>> t.ts.isoformat()
  '2019-01-01T12:00:00+00:00'

  >>> t.maybe = None
  >>> t.to_dict()
  {'ts': '2019-01-01T12:00:00Z', 'duration': '1.200s'}
  ```



  First, make sure you have Python 3.6+ and `pipenv` installed, along with the official [Protobuf Compiler](https://github.com/protocolbuffers/protobuf/releases) for your platform. Then:

  ```sh

  $ pipenv install --dev


  $ pipenv shell
  $ pip install -e .
  ```



  This project enforces [black](https://github.com/psf/black) python code formatting.

  Before commiting changes run:

  ```bash
  pipenv run black .
  ```

  To avoid merge conflicts later, non-black formatted python code will fail in CI.



  There are two types of tests:

  1. Standard tests
  2. Custom tests



  Adding a standard test case is easy.

  - Create a new directory `betterproto/tests/inputs/<name>`
    - add `<name>.proto`  with a message called `Test`
    - add `<name>.json` with some test data

  It will be picked up automatically when you run the tests.

  - See also: [Standard Tests Development Guide](betterproto/tests/README.md)



  Custom tests are found in `tests/test_*.py` and are run with pytest.



  Here's how to run the tests.

  ```sh

  $ pipenv run generate


  $ pipenv run test
  ```



  - [x] Fixed length fields
    - [x] Packed fixed-length
  - [x] Zig-zag signed fields (sint32, sint64)
  - [x] Don't encode zero values for nested types
  - [x] Enums
  - [x] Repeated message fields
  - [x] Maps
    - [x] Maps of message fields
  - [x] Support passthrough of unknown fields
  - [x] Refs to nested types
  - [x] Imports in proto files
  - [x] Well-known Google types
    - [ ] Support as request input
    - [ ] Support as response output
      - [ ] Automatically wrap/unwrap responses
  - [x] OneOf support
    - [x] Basic support on the wire
    - [x] Check which was set from the group
    - [x] Setting one unsets the others
  - [ ] JSON that isn't completely naive.
    - [x] 64-bit ints as strings
    - [x] Maps
    - [x] Lists
    - [x] Bytes as base64
    - [ ] Any support
    - [x] Enum strings
    - [x] Well known types support (timestamp, duration, wrappers)
    - [x] Support different casing (orig vs. camel vs. others?)
  - [ ] Async service stubs
    - [x] Unary-unary
    - [x] Server streaming response
    - [ ] Client streaming request
  - [x] Renaming messages and fields to conform to Python name standards
  - [x] Renaming clashes with language keywords
  - [x] Python package
  - [x] Automate running tests
  - [ ] Cleanup!



  Copyright © 2019 Daniel G. Taylor

  http://dgt.mit-license.org/


pkgId: 0183c255d59e7e8609687e9e3205a45758a3a36ad11ef2b94e76de8cc3375de4
name: python-betterproto-beta9
arch: src
version: 2.0.0b7
epoch: 0
release: 1
summary: A better Protobuf / gRPC generator & library
url: https://github.com/beam-cloud/python-betterproto
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-betterproto-beta9-2.0.0b7-1.src.rpm
checksum_type: sha256
description:
  ![](https://github.com/danielgtaylor/python-betterproto/workflows/CI/badge.svg)
  > :octocat: If you're reading this on github, please be aware that it might mention unreleased features! See the latest released README on [pypi](https://pypi.org/project/betterproto/).

  This project aims to provide an improved experience when using Protobuf / gRPC in a modern Python environment by making use of modern language features and generating readable, understandable, idiomatic Python code. It will not support legacy features or environments (e.g. Protobuf 2). The following are supported:

  - Protobuf 3 & gRPC code generation
    - Both binary & JSON serialization is built-in
  - Python 3.7+ making use of:
    - Enums
    - Dataclasses
    - `async`/`await`
    - Timezone-aware `datetime` and `timedelta` objects
    - Relative imports
    - Mypy type checking
  - [Pydantic Models](https://docs.pydantic.dev/) generation (see #generating-pydantic-models)

  This project is heavily inspired by, and borrows functionality from:

  - https://github.com/protocolbuffers/protobuf/tree/master/python
  - https://github.com/eigenein/protobuf/
  - https://github.com/vmagamedov/grpclib



  This project exists because I am unhappy with the state of the official Google protoc plugin for Python.

  - No `async` support (requires additional `grpclib` plugin)
  - No typing support or code completion/intelligence (requires additional `mypy` plugin)
  - No `__init__.py` module files get generated
  - Output is not importable
    - Import paths break in Python 3 unless you mess with `sys.path`
  - Bugs when names clash (e.g. `codecs` package)
  - Generated code is not idiomatic
    - Completely unreadable runtime code-generation
    - Much code looks like C++ or Java ported 1:1 to Python
    - Capitalized function names like `HasField()` and `SerializeToString()`
    - Uses `SerializeToString()` rather than the built-in `__bytes__()`
    - Special wrapped types don't use Python's `None`
    - Timestamp/duration types don't use Python's built-in `datetime` module


  This project is a reimplementation from the ground up focused on idiomatic modern Python to help fix some of the above. While it may not be a 1:1 drop-in replacement due to changed method names and call patterns, the wire format is identical.



  First, install the package. Note that the `[compiler]` feature flag tells it to install extra dependencies only needed by the `protoc` plugin:

  ```sh

  pip install "betterproto[compiler]"


  pip install betterproto
  ```

  *Betterproto* is under active development. To install the latest beta version, use `pip install --pre betterproto`.





  Given you installed the compiler and have a proto file, e.g `example.proto`:

  ```protobuf
  syntax = "proto3";

  package hello;

  // Greeting represents a message you can tell a user.
  message Greeting {
    string message = 1;
  }
  ```

  You can run the following to invoke protoc directly:

  ```sh
  mkdir lib
  protoc -I . --python_betterproto_out=lib example.proto
  ```

  or run the following to invoke protoc via grpcio-tools:

  ```sh
  pip install grpcio-tools
  python -m grpc_tools.protoc -I . --python_betterproto_out=lib example.proto
  ```

  This will generate `lib/hello/__init__.py` which looks like:

  ```python



  from dataclasses import dataclass

  import betterproto


  @dataclass
  class Greeting(betterproto.Message):
      """Greeting represents a message you can tell a user."""

      message: str = betterproto.string_field(1)
  ```

  Now you can use it!

  ```python
  >>> from lib.hello import Greeting
  >>> test = Greeting()
  >>> test
  Greeting(message='')

  >>> test.message = "Hey!"
  >>> test
  Greeting(message="Hey!")

  >>> serialized = bytes(test)
  >>> serialized
  b'\n\x04Hey!'

  >>> another = Greeting().parse(serialized)
  >>> another
  Greeting(message="Hey!")

  >>> another.to_dict()
  {"message": "Hey!"}
  >>> another.to_json(indent=2)
  '{\n  "message": "Hey!"\n}'
  ```



  The generated Protobuf `Message` classes are compatible with [grpclib](https://github.com/vmagamedov/grpclib) so you are free to use it if you like. That said, this project also includes support for async gRPC stub generation with better static type checking and code completion support. It is enabled by default.

  Given an example service definition:

  ```protobuf
  syntax = "proto3";

  package echo;

  message EchoRequest {
    string value = 1;
    // Number of extra times to echo
    uint32 extra_times = 2;
  }

  message EchoResponse {
    repeated string values = 1;
  }

  message EchoStreamResponse  {
    string value = 1;
  }

  service Echo {
    rpc Echo(EchoRequest) returns (EchoResponse);
    rpc EchoStream(EchoRequest) returns (stream EchoStreamResponse);
  }
  ```

  Generate echo proto file:

  ```
  python -m grpc_tools.protoc -I . --python_betterproto_out=. echo.proto
  ```

  A client can be implemented as follows:
  ```python
  import asyncio
  import echo

  from grpclib.client import Channel


  async def main():
      channel = Channel(host="127.0.0.1", port=50051)
      service = echo.EchoStub(channel)
      response = await service.echo(echo.EchoRequest(value="hello", extra_times=1))
      print(response)

      async for response in service.echo_stream(echo.EchoRequest(value="hello", extra_times=1)):
          print(response)

      
      channel.close()


  if __name__ == "__main__":
      loop = asyncio.get_event_loop()
      loop.run_until_complete(main())

  ```

  which would output
  ```python
  EchoResponse(values=['hello', 'hello'])
  EchoStreamResponse(value='hello')
  EchoStreamResponse(value='hello')
  ```

  This project also produces server-facing stubs that can be used to implement a Python
  gRPC server.
  To use them, simply subclass the base class in the generated files and override the
  service methods:

  ```python
  import asyncio
  from echo import EchoBase, EchoRequest, EchoResponse, EchoStreamResponse
  from grpclib.server import Server
  from typing import AsyncIterator


  class EchoService(EchoBase):
      async def echo(self, echo_request: "EchoRequest") -> "EchoResponse":
          return EchoResponse([echo_request.value for _ in range(echo_request.extra_times)])

      async def echo_stream(self, echo_request: "EchoRequest") -> AsyncIterator["EchoStreamResponse"]:
          for _ in range(echo_request.extra_times):
              yield EchoStreamResponse(echo_request.value)


  async def main():
      server = Server([EchoService()])
      await server.start("127.0.0.1", 50051)
      await server.wait_closed()

  if __name__ == '__main__':
      loop = asyncio.get_event_loop()
      loop.run_until_complete(main())
  ```



  Both serializing and parsing are supported to/from JSON and Python dictionaries using the following methods:

  - Dicts: `Message().to_dict()`, `Message().from_dict(...)`
  - JSON: `Message().to_json()`, `Message().from_json(...)`

  For compatibility the default is to convert field names to `camelCase`. You can control this behavior by passing a casing value, e.g:

  ```python
  MyMessage().to_dict(casing=betterproto.Casing.SNAKE)
  ```



  Sometimes it is useful to be able to determine whether a message has been sent on the wire. This is how the Google wrapper types work to let you know whether a value is unset, set as the default (zero value), or set as something else, for example.

  Use `betterproto.serialized_on_wire(message)` to determine if it was sent. This is a little bit different from the official Google generated Python code, and it lives outside the generated `Message` class to prevent name clashes. Note that it **only** supports Proto 3 and thus can **only** be used to check if `Message` fields are set. You cannot check if a scalar was sent on the wire.

  ```py

  >>> mymessage.HasField('myfield')


  >>> betterproto.serialized_on_wire(mymessage.myfield)
  ```



  Protobuf supports grouping fields in a `oneof` clause. Only one of the fields in the group may be set at a given time. For example, given the proto:

  ```protobuf
  syntax = "proto3";

  message Test {
    oneof foo {
      bool on = 1;
      int32 count = 2;
      string name = 3;
    }
  }
  ```

  On Python 3.10 and later, you can use a `match` statement to access the provided one-of field, which supports type-checking:

  ```py
  test = Test()
  match test:
      case Test(on=value):
          print(value)  # value: bool
      case Test(count=value):
          print(value)  # value: int
      case Test(name=value):
          print(value)  # value: str
      case _:
          print("No value provided")
  ```

  You can also use `betterproto.which_one_of(message, group_name)` to determine which of the fields was set. It returns a tuple of the field name and value, or a blank string and `None` if unset.

  ```py
  >>> test = Test()
  >>> betterproto.which_one_of(test, "foo")
  ["", None]

  >>> test.on = True
  >>> betterproto.which_one_of(test, "foo")
  ["on", True]


  >>> test.count = 57
  >>> betterproto.which_one_of(test, "foo")
  ["count", 57]


  >>> test.name = ""
  >>> betterproto.which_one_of(test, "foo")
  ["name", ""]
  ```

  Again this is a little different than the official Google code generator:

  ```py

  >>> message.WhichOneof("group")
  "foo"


  >>> betterproto.which_one_of(message, "group")
  ["foo", "foo's value"]
  ```



  Google provides several well-known message types like a timestamp, duration, and several wrappers used to provide optional zero value support. Each of these has a special JSON representation and is handled a little differently from normal messages. The Python mapping for these is as follows:

  | Google Message              | Python Type                              | Default                |
  | --------------------------- | ---------------------------------------- | ---------------------- |
  | `google.protobuf.duration`  | [`datetime.timedelta`][td]               | `0`                    |
  | `google.protobuf.timestamp` | Timezone-aware [`datetime.datetime`][dt] | `1970-01-01T00:00:00Z` |
  | `google.protobuf.*Value`    | `Optional[...]`                          | `None`                 |
  | `google.protobuf.*`         | `betterproto.lib.google.protobuf.*`      | `None`                 |

  [td]: https://docs.python.org/3/library/datetime.html#timedelta-objects
  [dt]: https://docs.python.org/3/library/datetime.html#datetime.datetime

  For the wrapper types, the Python type corresponds to the wrapped type, e.g. `google.protobuf.BoolValue` becomes `Optional[bool]` while `google.protobuf.Int32Value` becomes `Optional[int]`. All of the optional values default to `None`, so don't forget to check for that possible state. Given:

  ```protobuf
  syntax = "proto3";

  import "google/protobuf/duration.proto";
  import "google/protobuf/timestamp.proto";
  import "google/protobuf/wrappers.proto";

  message Test {
    google.protobuf.BoolValue maybe = 1;
    google.protobuf.Timestamp ts = 2;
    google.protobuf.Duration duration = 3;
  }
  ```

  You can do stuff like:

  ```py
  >>> t = Test().from_dict({"maybe": True, "ts": "2019-01-01T12:00:00Z", "duration": "1.200s"})
  >>> t
  Test(maybe=True, ts=datetime.datetime(2019, 1, 1, 12, 0, tzinfo=datetime.timezone.utc), duration=datetime.timedelta(seconds=1, microseconds=200000))

  >>> t.ts - t.duration
  datetime.datetime(2019, 1, 1, 11, 59, 58, 800000, tzinfo=datetime.timezone.utc)

  >>> t.ts.isoformat()
  '2019-01-01T12:00:00+00:00'

  >>> t.maybe = None
  >>> t.to_dict()
  {'ts': '2019-01-01T12:00:00Z', 'duration': '1.200s'}
  ```



  You can use python-betterproto to generate pydantic based models, using
  pydantic dataclasses. This means the results of the protobuf unmarshalling will
  be typed checked. The usage is the same, but you need to add a custom option
  when calling the protobuf compiler:


  ```
  protoc -I . --python_betterproto_opt=pydantic_dataclasses --python_betterproto_out=lib example.proto
  ```

  With the important change being `--python_betterproto_opt=pydantic_dataclasses`. This will
  swap the dataclass implementation from the builtin python dataclass to the
  pydantic dataclass. You must have pydantic as a dependency in your project for
  this to work.





  - _Join us on [Slack](https://join.slack.com/t/betterproto/shared_invite/zt-f0n0uolx-iN8gBNrkPxtKHTLpG3o1OQ)!_
  - _See how you can help &rarr; [Contributing](.github/CONTRIBUTING.md)_



  - Python (3.7 or higher)

  - [poetry](https://python-poetry.org/docs/#installation)
    *Needed to install dependencies in a virtual environment*

  - [poethepoet](https://github.com/nat-n/poethepoet) for running development tasks as defined in pyproject.toml
    - Can be installed to your host environment via `pip install poethepoet` then executed as simple `poe`
    - or run from the poetry venv as `poetry run poe`



  ```sh

  poetry install -E compiler


  poetry shell
  ```



  This project enforces [black](https://github.com/psf/black) python code formatting.

  Before committing changes run:

  ```sh
  poe format
  ```

  To avoid merge conflicts later, non-black formatted python code will fail in CI.



  There are two types of tests:

  1. Standard tests
  2. Custom tests



  Adding a standard test case is easy.

  - Create a new directory `betterproto/tests/inputs/<name>`
    - add `<name>.proto`  with a message called `Test`
    - add `<name>.json` with some test data (optional)

  It will be picked up automatically when you run the tests.

  - See also: [Standard Tests Development Guide](tests/README.md)



  Custom tests are found in `tests/test_*.py` and are run with pytest.



  Here's how to run the tests.

  ```sh

  poe generate

  poe test
  ```

  To run tests as they are run in CI (with tox) run:

  ```sh
  poe full-test
  ```



  Betterproto includes compiled versions for Google's well-known types at [src/betterproto/lib/google](src/betterproto/lib/google).
  Be sure to regenerate these files when modifying the plugin output format, and validate by running the tests.

  Normally, the plugin does not compile any references to `google.protobuf`, since they are pre-compiled. To force compilation of `google.protobuf`, use the option `--custom_opt=INCLUDE_GOOGLE`.

  Assuming your `google.protobuf` source files (included with all releases of `protoc`) are located in `/usr/local/include`, you can regenerate them as follows:

  ```sh
  protoc \
      --plugin=protoc-gen-custom=src/betterproto/plugin/main.py \
      --custom_opt=INCLUDE_GOOGLE \
      --custom_out=src/betterproto/lib \
      -I /usr/local/include/ \
      /usr/local/include/google/protobuf/*.proto
  ```



  - [x] Fixed length fields
    - [x] Packed fixed-length
  - [x] Zig-zag signed fields (sint32, sint64)
  - [x] Don't encode zero values for nested types
  - [x] Enums
  - [x] Repeated message fields
  - [x] Maps
    - [x] Maps of message fields
  - [x] Support passthrough of unknown fields
  - [x] Refs to nested types
  - [x] Imports in proto files
  - [x] Well-known Google types
    - [ ] Support as request input
    - [ ] Support as response output
      - [ ] Automatically wrap/unwrap responses
  - [x] OneOf support
    - [x] Basic support on the wire
    - [x] Check which was set from the group
    - [x] Setting one unsets the others
  - [ ] JSON that isn't completely naive.
    - [x] 64-bit ints as strings
    - [x] Maps
    - [x] Lists
    - [x] Bytes as base64
    - [ ] Any support
    - [x] Enum strings
    - [x] Well known types support (timestamp, duration, wrappers)
    - [x] Support different casing (orig vs. camel vs. others?)
  - [x] Async service stubs
    - [x] Unary-unary
    - [x] Server streaming response
    - [x] Client streaming request
  - [x] Renaming messages and fields to conform to Python name standards
  - [x] Renaming clashes with language keywords
  - [x] Python package
  - [x] Automate running tests
  - [ ] Cleanup!



  Join us on [Slack](https://join.slack.com/t/betterproto/shared_invite/zt-f0n0uolx-iN8gBNrkPxtKHTLpG3o1OQ)!



  Copyright © 2019 Daniel G. Taylor

  http://dgt.mit-license.org/


pkgId: 706595e14805c990235a97bf5cf5588bcc0a1f4073bd8e779788ba3acbc09e8a
name: python-bettershot
arch: src
version: 0.1.92
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/bettershot/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bettershot-0.1.92-1.src.rpm
checksum_type: sha256
description:
  ⚡️ A Python package for adding error monitoring to LLM Apps in a few minutes ⚡

  >BetterShot by BerriAI let’s you add error (hallucinations/refusal to answer) monitoring to your LLM App in a few minutes. Like Bugsnag/Sentry for LLM apps!



  Install bettershot by running this command.:

  `pip install bettershot`



  It's just 1 line of code:

  `log(messages=messages, completion=result, user_email="YOUR_EMAIL", query=query)`

  ![7f11c616-853a-4016-802c-ef705dea51c7](https://github.com/ClerkieAI/bettershot/assets/17561003/c16c7149-bf57-4fc1-8f50-76e16850a0a2)



  All your logs are available @ 'https://better-test.vercel.app/' + YOUR_EMAIL

  e.g.
  `log(messages=messages, completion=result, user_email="krrish@berri.ai", query=query)`

  will have it's results logged @

  `https://better-test.vercel.app/krrish@berri.ai`



  Here are all the items you can log:

  | Parameter | Type | Required/Optional | Description |
  | --------- | ---- | ----------------- | ----------- |
  | `messages` | List | Required | The list of messages sent to the OpenAI chat completions endpoint |
  | `completion` | Dictionary | Required | The response received from the OpenAI chat completions endpoint |
  | `user_email` | String | Required | Your user email |
  | `query` | String | Required | The query being asked by your user |
  | `customer_id` | String | Optional | A way to identify your customer |

  Here's 2 examples of using it:


  ```
  from bettershot import log
  import openai

  def simple_openai_call(query):
      messages = [{'role': 'user', 'content': query}]
      completion = openai.ChatCompletion.create(
                  model="gpt-3.5-turbo",
                  messages=messages

              )
      log(messages=messages, completion=completion, user_email="YOUR_EMAIL", query=query, customer_id="fake_user@fake_accounts.xyz") #JUST 1 LINE OF CODE 🤯

  simple_openai_call("hey! how's it going?")
  ```



  ```
  import openai
  import langchain
  from bettershot import log

  def simple_langchain_call(query):
      chat = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7)
      prompt = "You are an extremely intelligent AI assistant for BerriAI, answer all questions resepectfully and in a warm tone"
      messages = [
        SystemMessage(content=prompt),
        HumanMessage(content=query)
      ]
      result = chat(messages)
      log(messages=messages, completion=completion, user_email="YOUR_EMAIL", query=query, customer_id="fake_user@fake_accounts.xyz") #JUST 1 LINE OF CODE 🎉

  simple_langchain_call("hey! how's it going?")
  ```

  bettershot automatically evaluates your OpenAI responses to determine if the model either invented new information (hallucination) or refused to answer ("Sorry, as an AI language model...") a user's question.



  Reliable + Fast testing is hard, and that's what we want to tackle.

  Each question is evaluated 3 times.

  Each evaluation returns either True or False, along with the model's rationale for why it chose what it did.

  We pick the evaluation (True/False) that occurs most, along with the model rationale to explain reasoning.

  Each question is run in parallel and results are added to your dashboard in real-time.

  >We will be sharing the prompts soon!



  We welcome contributions to bettershot! Feel free to create issues/PR's/or DM us (👋 Hi I'm Krrish - +17708783106)



  bettershot is released under the [MIT License](https://github.com/bettershot/readme/blob/master/LICENSE).


pkgId: 618eb08a765dd2992ef059169333e83f2d6c83d67cdfe74ab751b51748fe4249
name: python-betterspread
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/betterspread/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-betterspread-0.2.2-1.src.rpm
checksum_type: sha256
description:
  A wrapper around gspread with cell and row level functionalities



  ```python
  from betterspread import Sheet, Connection

  con = Connection(credentials_path="./credentials.json")
  sheet = Sheet(connection=con, sheet_name="Better Sheet")
  tab = await sheet.get_tab('Sheet1')
  ```
  `Sheet` is a subclass of gsprad's `Spreadsheet`


  ```python
  await tab.values() # returns a list of rows
  ```


  row is a subclass of list, with functionalities like `update` and `clear`
  ```python
  row = await tab.get_row(1) # returns a Row
  print(row)
  ```


  ```python
  await row.update(['new', 'values'])
  await row.clear() # clear all value of the row
  ```

  cell is a subclass of string, with additional functionalities like `update` and `clear`
  ```python
  cell = await tab.get_cell('A1') # returns a Cell
  cell = row[0] # same as above
  ```


  ```python
  await cell.update('New cell value')
  await cell.clear() # clear value of the cell
  ```


pkgId: 3ddae1be7a6bf54ef2f3bfbdd7cb335c60d328a89cb8209e355eed7c82ea0cf1
name: python-bettertest
arch: src
version: 0.1.98
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/bettertest/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bettertest-0.1.98-1.src.rpm
checksum_type: sha256
description:
  ⚡ A Python testing library for automatically evaluating and tracing LLM applications ⚡

  Our goal with bettertest is to simplify the process of testing and debugging LLM applications. It automatically evaluates your model's responses against your solution answers (auto-eval) and provides tracing features out-of-the-box.

  With bettertest, you can automatically test your LLM applications and view print statements for each run just by adding 'bettertest' to any print statement in your code.



  Before using BetterTest, you need to install it via pip:

  ```
  pip install bettertest
  ```

  After installation, import the BetterTest library in your Python project:

  ```python
  from bettertest import BetterTest
  ```




  ```
  !pip install bettertest

  from bettertest import BetterTest

  questions = ['what does a complex QA instance mean?',
   '<@1098583990618837062> how can I train an instance based off of a websites documentation, without using PDF? could i web scrape the content and then upload that content? i am trying to ask questions based off of a websites documentation, and im not sure how to convert the data from the website easily',
   '<@1098583990618837062> how can i train an instance based off of a websites documentation?',
  '<@1098583990618837062> What does the ai model see the data as? Does it see it as the large corpus of text it is trained on or something else?']

  def call_openai(question):
      index = questions.index(question)

      model_answers = ['A complex QA instance refers to a type of search in which users ask questions that require multiple pieces of context. For example, if a user asks "What is the age of the actress who plays Meg in Family Guy?", the system needs to know both "Who plays Meg in Family Guy?" and "What is Mila Kunis\'s age?" to provide an accurate answer. To handle this, the user question is broken down into sub-components, and the most relevant chunks for each sub-question are found and fed into the chatGPT/GPT-4 model to get the answer.\n  \n  REFERENCES\n Discord Chat; https://docs.berri.ai/api-reference/app_configurations/file_configuration;',
   "To train an instance based off of a website's documentation without using a PDF, you can scrape the content from the website and then upload it as a data source. You can use web scraping tools such as Beautiful Soup or Scrapy to extract the text from the website and then upload it using the BerriAI API. Once you have uploaded the data source, you can use it to train your instance and ask questions based on the website's documentation. However, please note that web scraping may be subject to legal restrictions, so make sure to check the website's terms of service and consult with a legal professional if necessary.\n  \n  REFERENCES\n Discord Chat;",
   'To train an instance based off of a website\'s documentation, you can use the "Recursive URLs" feature provided by BerriAI. This feature allows you to recursively parse URLs and extract text data from them, which can then be used to train your instance. \n \n\n Here\'s an example of how you can use this feature:\n \n\n 1. First, create a data source using the "create_data_source" endpoint. You can specify the URL of the website you want to train your instance on as the "data_source" parameter. \n \n\n 2. Next, use the "create_app" endpoint to create an instance of your GPT-4 app. In the payload, specify the "data_source" parameter as the ID of the data source you created in step 1. \n \n\n 3. Finally, use the "finetune_instance" endpoint to fine-tune your instance using the data extracted from the website. You can pass in a list of JSON objects containing context and correct_response attributes to this endpoint. \n \n\n Keep in mind that the quality of the instance you train will depend on the quality of the data you extract from the website. It\'s important to ensure that the data you extract is relevant and accurate.\n  \n  REFERENCES\n Discord Chat;',
   'Hello <@1098583990618837062>, according to the BerriAI API documentation, the AI model sees the data as embeddings, which are numerical representations of the text. These embeddings are generated using a pre-trained language model, such as GPT-3, and are used to make predictions and generate responses. The model does not see the data as the large corpus of text it is trained on, but rather as a set of numerical vectors that represent the semantic meaning of the text.\n  \n  REFERENCES\n Discord Chat;']
      print("bettertest: testing if this works")
      return model_answers[index]

  answers = ['Sometimes users ask questions that require multiple pieces of context (e.g. What is the age of the actress who plays Meg in Family Guy? -> This requires us to know - Who plays Meg in Family Guy? Mila Kunis + What is Mila Kunis’s age?). To tackle this, we first run the user question through chatGPT, and have it break down that question into sub-components (as seen in the previous example) -> Find the most relevant chunks for each sub-question -> Feed that into chatGPT/GPT-4/whichever model you chose to get the answer to the users question.',
   "You can either create an app with an input_url this way you won't need to scrape the website https://docs.berri.ai/api-reference/endpoint/create_app if this does not work you can also manually scrape the website yourself and create an instance with raw text by passing in JSON chunks to berri",
   "You can either create an app with an input_url this way you won't need to scrape the website https://docs.berri.ai/api-reference/endpoint/create_app if this does not work you can also manually scrape the website yourself and create an instance with raw text by passing in JSON chunks to berri",
   "Berri ingests your data, chunks it, creates embeddings. When user's ask questions, berri does a similarity search and retrieves the most similar chunks to answer the questions. These chunks are then fed into the llm to answer the question"]

  bt = BetterTest("krrish@berri.ai", "YOUR_OPENAI_API_KEY")

  bt.eval(questions, answers, call_openai)

  ```



  Create an instance of the BetterTest class with the user's email:

  ```python
  bt = BetterTest("your_email@example.com", "your_openai_api_key")
  ```

  Replace `"your_email@example.com"` with the appropriate email address.
  Replace `"your_openai_api_key"` with your openai api key. [Here's where to find it](https://platform.openai.com/account/api-keys).



  The `eval()` function takes in a list of questions, a list of answers, an LLM function, and an optional `num_runs` argument. It automatically evaluates the model's response against the solution answer and provides tracing for each run. Use it as follows:

  ```python
  questions = [...]  # List of questions
  answers = [...]    # List of corresponding solution answers

  def llm_function(question):
      
      pass

  bt = BetterTest("your_email@example.com")
  bt.eval(questions, answers, llm_function)
  ```

  Replace the `llm_function` with your LLM function, and customize `num_runs` if necessary. By default, `num_runs` is set to 1.




  We welcome contributions to InstructPrompt! Feel free to create issues/PR's/or DM us (👋 Hi I'm Krrish - +17708783106)



  The current version of BetterTest is `0.1.9`.



  BetterTest is released under the [MIT License](https://github.com/bettertest/readme/blob/master/LICENSE).


pkgId: ebe5532089b7d107a61bb55c6c94ca6e6c4fae6d61b59c8a2dd0a0b3ceba103a
name: python-betty-nginx
arch: src
version: 0.1.0b4
epoch: 0
release: 1
summary: Nginx for Betty provides nginx and Docker integration for your Betty sites
url: https://pypi.org/project/betty-nginx/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-betty-nginx-0.1.0b4-1.src.rpm
checksum_type: sha256
description:
  [![Test](https://github.com/bartfeenstra/betty-nginx/actions/workflows/test.yml/badge.svg?branch=0.1.x)](https://github.com/bartfeenstra/betty-nginx/actions/workflows/test.yml) [![Code coverage](https://codecov.io/gh/bartfeenstra/betty-nginx/branch/0.1.x/graph/badge.svg)](https://codecov.io/gh/bartfeenstra/betty-nginx) [![PyPI releases](https://badge.fury.io/py/betty-nginx.svg)](https://pypi.org/project/betty-nginx/) [![Supported Python versions](https://img.shields.io/pypi/pyversions/betty-nginx.svg?logo=python&logoColor=FBE072)](https://pypi.org/project/betty-nginx/) [![Recent downloads](https://img.shields.io/pypi/dm/betty-nginx.svg)](https://pypi.org/project/betty-nginx/) [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](CODE_OF_CONDUCT.md)  [![Follow Betty on Twitter](https://img.shields.io/twitter/follow/Betty_Project.svg?label=Betty_Project&style=flat&logo=twitter&logoColor=4FADFF)](https://twitter.com/Betty_Project)

rpm_license:
  GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The GNU General Public License is a free, copyleft license for software and other kinds of works.  The licenses for most software and other practical works are designed to take away your freedom to share and change the works.  By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users.  We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors.  You can apply it to your programs, too.  When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.  To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights.  Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others.  For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received.  You must make sure that they, too, receive or can get the source code.  And you must show them these terms so they know their rights.  Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it.  For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software.  For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions.  Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so.  This is fundamentally incompatible with the aim of protecting users' freedom to change the software.  The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable.  Therefore, we have designed this version of the GPL to prohibit the practice for those products.  If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users.  Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary.  To prevent this, the GPL assures that patents cannot be used to render the program non-free.  The precise terms and conditions for copying, distribution and modification follow.  TERMS AND CONDITIONS  0. Definitions.  "This License" refers to version 3 of the GNU General Public License.  "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.  "The Program" refers to any copyrightable work licensed under this License.  Each licensee is addressed as "you".  "Licensees" and "recipients" may be individuals or organizations.  To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy.  The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work.  A "covered work" means either the unmodified Program or a work based on the Program.  To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy.  Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.  To "convey" a work means any kind of propagation that enables other parties to make or receive copies.  Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.  An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License.  If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.  1. Source Code.  The "source code" for a work means the preferred form of the work for making modifications to it.  "Object code" means any non-source form of a work.  A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.  The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form.  A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.  The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities.  However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work.  For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.  The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.  The Corresponding Source for a work in source code form is that same work.  2. Basic Permissions.  All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met.  This License explicitly affirms your unlimited permission to run the unmodified Program.  The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work.  This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.  You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force.  You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright.  Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.  Conveying under any other circumstances is permitted solely under the conditions stated below.  Sublicensing is not allowed; section 10 makes it unnecessary.  3. Protecting Users' Legal Rights From Anti-Circumvention Law.  No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.  When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.  4. Conveying Verbatim Copies.  You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.  You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.  5. Conveying Modified Source Versions.  You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:  a) The work must carry prominent notices stating that you modified it, and giving a relevant date.  b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7.  This requirement modifies the requirement in section 4 to "keep intact all notices".  c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy.  This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged.  This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.  d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.  A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit.  Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.  6. Conveying Non-Source Forms.  You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:  a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.  b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.  c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source.  This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.  d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge.  You need not require recipients to copy the Corresponding Source along with the object code.  If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source.  Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.  e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.  A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.  A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling.  In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage.  For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product.  A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.  "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source.  The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.  If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information.  But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).  The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed.  Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.  Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.  7. Additional Terms.  "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law.  If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.  When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it.  (Additional permissions may be written to require their own removal in certain cases when you modify the work.)  You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.  Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:  a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or  b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or  c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or  d) Limiting the use for publicity purposes of names of licensors or authors of the material; or  e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or  f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.  All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10.  If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term.  If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.  If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.  Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.  8. Termination.  You may not propagate or modify a covered work except as expressly provided under this License.  Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).  However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.  Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.  Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License.  If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.  9. Acceptance Not Required for Having Copies.  You are not required to accept this License in order to receive or run a copy of the Program.  Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance.  However, nothing other than this License grants you permission to propagate or modify any covered work.  These actions infringe copyright if you do not accept this License.  Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.  10. Automatic Licensing of Downstream Recipients.  Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License.  You are not responsible for enforcing compliance by third parties with this License.  An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations.  If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.  You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License.  For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.  11. Patents.  A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based.  The work thus licensed is called the contributor's "contributor version".  A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version.  For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.  Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.  In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement).  To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.  If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients.  "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.  If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.  A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License.  You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.  Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.  12. No Surrender of Others' Freedom.  If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all.  For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.  13. Use with the GNU Affero General Public License.  Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work.  The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such.  14. Revised Versions of this License.  The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation.  If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.  Later license versions may give you additional or different permissions.  However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.  15. Disclaimer of Warranty.  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. Limitation of Liability.  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  17. Interpretation of Sections 15 and 16.  If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.  END OF TERMS AND CONDITIONS


pkgId: 0706f3c3d08f00210d2df37a18df7ec08f7afdb11e83d7b61862f94239187030
name: python-bettyfixer
arch: src
version: 1.4.6
epoch: 0
release: 1
url: https://github.com/Moealsir/betty_fixer
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bettyfixer-1.4.6-1.src.rpm
checksum_type: sha256
summary:
  Betty Fixer is a tool designed to automatically fix coding style issues in C files based on the Betty coding style guidelines. It performs corrections to ensure that the code complies with the Betty style, making it more readable and consistent.

description:
  Betty Fixer is a tool designed to automatically fix coding style issues in C files based on the Betty coding style guidelines. It performs corrections to ensure that the code complies with the Betty style, making it more readable and consistent.



  - **Betty Style Fixes**: Automatically corrects coding style issues following the Betty style guidelines.
  - **Vi Script Execution**: Runs a Vi script for each fixed file, making it convenient for developers to review and further modify the code.
  - **Create header.h**: You can now create header file by specifing header file name after flag -H .



  Before using Betty Fixer, ensure you have the following installed:

  - [Betty](https://github.com/holbertonschool/Betty) - The Betty linter for C code.
  - [Vi Editor](https://www.vim.org/) - The Vi editor for script execution.
  - <span style="color:#a93226;">Ctags</span> :-

          sudo apt-get install exuberant-ctags


  1. Clone the repository:

      ```bash
      pip install bettyfixer
      ```

  2. Run Betty Fixer on your C files:

      ```bash
      bettyfixer file1.c file2.c ...
      ```

  3. To create header file run:

      ```bash
      bettyfixer -H <header_name>.h ...
      ```


  The current release of `bettyfixer` is optimized for Ubuntu 20.04 LTS (Focal Fossa). We are actively working to expand compatibility to include other Ubuntu releases in future updates. Stay tuned for upcoming releases that will offer support for a broader range of Ubuntu versions.




  If you'd like to contribute to Betty Fixer, please follow these steps:

  1. Go to the [Github repository](https://github.com/Moealsir/betty_fixer)
  2. Fork the repository.
  3. Create a new branch for your feature or bug fix.
  4. Make your changes and ensure the code style follows the project conventions.
  5. Test your changes thoroughly.
  6. Create a pull request with a clear description of your changes.






  [@Moealsir](https://github.com/Moealsir) <br>
  [@Malazmuzamil98](https://github.com/malazmuzamil98)<br>
  [@AhedEisa](https://github.com/be-great)


pkgId: aa2b465f46377ec6c6b4807f8183212b0ff6aa1bb88ecf95d9e2fcddb68aae8d
name: python-betwatch
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: A Python package for interacting with the Betwatch.com API
url: https://pypi.org/project/betwatch/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-betwatch-1.4.0-1.src.rpm
checksum_type: sha256
description:
  The Betwatch Python SDK allows you to interact with the [Betwatch.com](https://www.betwatch.com) API to integrate up to date racing price data into your Python applications.

  This library is provided on a best-effort basis in order to lower the barrier of entry for accessing the Betwatch API. No guarantees are made for the reliability of this library and development will be ongoing.

  ```console
  pip install betwatch
  ```

  See [examples](https://github.com/betwatch/betwatch-sdk-python/tree/main/examples)
  A Betwatch API key is required. Please contact [api@betwatch.com](mailto:api@betwatch.com) for more information.


pkgId: ca4afa67f750398b837e257fae1e722de08aef8a0841b92c9829a0a6fe91166f
name: python-betweens
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: 0.0.1:
url: https://pypi.org/project/betweens/
rpm_license: Academic Free License (AFL)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-betweens-1.2.2-1.src.rpm
checksum_type: sha256
description:
  This is a package named betweens.
  There are 3 between mode.



  two intergers.



  two lists, tuples or dicts.
  And two indexes.



  two length, area, volume or mass units


pkgId: 6910fe281f1dee1ea01d4f296926e38e7e745721cef5b47675c4930925fc8054
name: python-bev
arch: src
version: 0.11.5
epoch: 0
release: 1
summary: A small manager for versioned data
url: https://github.com/neuro-ml/bev
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bev-0.11.5-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/neuro-ml/bev/branch/master/graph/badge.svg)](https://codecov.io/gh/neuro-ml/bev)
  [![pypi](https://img.shields.io/pypi/v/bev?logo=pypi&label=PyPi)](https://pypi.org/project/bev/)
  ![License](https://img.shields.io/github/license/neuro-ml/bev)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/bev)](https://pypi.org/project/bev/)
  ![GitHub branch checks state](https://img.shields.io/github/checks-status/neuro-ml/bev/master)

  Flexible version control for files and folders.



  The simplest way is to get it from PyPi:

  ```shell
  pip install bev
  ```





  ```shell
  ls

  bev add image.png
  ls

  bev add ids.json some-folder
  ls


  git add image.png.hash ids.json.hash some-folder.hash
  git commit -m "added new files"
  ```



  ```shell
  ls

  bev pull image.png.hash --mode copy
  ls

  bev pull some-folder.hash --mode copy
  ls

  ```



  In this recipe we "expand" the hashed folder and fill it with the hashes of the files it contains.
  This is much faster than copying back the entire folder.

  ```shell
  ls

  bev pull some-folder.hash --mode hash
  ls

  ls some-folder

  ```

  Afterwards you can add the folder back

  ```shell
  bev add some-folder
  ls

  ```



  1. Choose a folder for your repository and create a basic config (`.bev.yml`):

  ```yaml
  main:
    storage: /path/to/storage/folder

  meta:
    hash: sha256
  ```

  2. Run `init`

  ```shell
  bev init
  ```

  3. Add files to bev

  ```shell
  bev add /path/to/some/file.json

  bev add /path/to/some/folder/ /path/to/some/image.png
  ```

  4. ... and to git

  ```shell
  git add file.json.hash folder.hash image.png.hash
  git commit -m "added files"
  ```

  5. Access the files from python

  ```python
  import imageio
  from bev import Repository


  repo = Repository('/path/to/repo', version='8a7fe6')
  image = imageio.imread(repo.resolve('image.png'))
  ```

  6. Or from cli

  ```shell

  bev pull folder.hash --mode hash

  bev pull folder.hash --mode copy

  bev pull image.png.hash --mode copy
  ```



  Here are some tutorials that cover more advanced configuration, including multiple storage locations and machines:

  1. [Create a repository](https://github.com/neuro-ml/bev/wiki/Creating-a-repository) - needed only at first time setup
  2. [Adding files](https://github.com/neuro-ml/bev/wiki/Adding-files)
  3. [Accessing files](https://github.com/neuro-ml/bev/wiki/Accessing-the-stored-files)



  [DVC](https://github.com/iterative/dvc) is a great project, and we took inspiration from it while designing `bev`.
  However, out lab has several requirements that `DVC` doesn't meet:

  1. Our data caches are spread across multiple HDDs - we need support for multiple cache locations
  2. We have multiple machines, and each of them has a different storage configuration: locations, number of HDDs, their
     volumes - we need a flexible way of choosing the right config depending on the machine
  3. Often we simultaneously conduct experiments on different versions of the same data - we need easy access to multiple
     version of the same data
  4. The need for `dvc checkout` after `git checkout` is error-prone, because it can lead to situations when the data is
     not consistent with the current commit - we need a more constrained relation between data and `git`

  `bev` supports all four out of the box!

  However, if these requirements are not essential to your project, you may want to stick with `DVC` - its community and
  tests coverage is much larger.

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  Copyright 2021-2022 NeuroML Group  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: 740ecbf99bbd59f689a90600741f60329b7446fb08334c7216b88101b9ebac25
name: python-bevigil-cli
arch: src
version: 1.0.14
epoch: 0
release: 1
summary: BeVigil OSINT CLI
url: https://osint.bevigil.com/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bevigil-cli-1.0.14-1.src.rpm
checksum_type: sha256
description:
  ![](./static/logo.png)
  `bevigil-cli` provides a unified command line interface and python library for using BeVigil OSINT API.


pkgId: 15a9385a4dbe03a779ffd8f4d2a483c6493f64c789cba76e5c4a6131100aa7dc
name: python-bewspweb
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Functions to extract data from a web page using selenium webdriver with not too much code.
url: https://github.com/marceloandrade93/bewspweb
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bewspweb-0.1.0-1.src.rpm
checksum_type: sha256
description:
  In this repository you can find a module that allows you to extract data from a homepage with some functions, passing a few parameters and storing them in a list.




  To use it assertively, it is necessary to install some modules.

  * Selenium
  * Webdriver-manager

  ```bash
  pip install selenium
  pip install webdriver-manager
  ```


  To install de package, just run the command:

  ```bash
  pip install bewspweb
  ```


  This module has some functions:


  This function is to start the driver and open the web page using the defined parameters.


  This function is to collect data from a web page defining the type of the element, the element itself, the type of the subelement, the subelement itself. The function returns a list with the data collected.


  This function is to print the collected data from a web page.



  * **Start driver with bewspweb()**

  ```python
  from bewspweb import bewspweb_start

  bewspweb_start(url_main="https://webscraper.io/test-sites/e-commerce/scroll")
  ```

  ```python
  from bewspweb import bewspweb_start

  bewspweb_start(url_main="https://webscraper.io/test-sites/e-commerce/scroll", headless=True, windows_mode="maximize", mute_audio=True)
  ```

  * **Collecting with bewspweb_weave()**

  ```python
  from bewspweb import bewspweb_start, bewspweb_weave
  from selenium.webdriver.common.by import By


  bewspweb_start(url_main="https://webscraper.io/test-sites/e-commerce/scroll")


  list_name = bewspweb_weave(type_element=By.XPATH,
      element="/html/body/div[1]/div[3]/div/div[2]/div[2]",
      type_subelement=By.XPATH,
      subelement="/html/body/div[1]/div[3]/div/div[2]/div[2]/div",
      selsubtag="a",
      subtag="title",
      tries=10)
  ```

  * **Printing with bewspweb_print()**

  ```python
  from bewspweb import bewspweb_start, bewspweb_weave, bewspweb_print
  from selenium.webdriver.common.by import By


  bewspweb_start(url_main="https://webscraper.io/test-sites/e-commerce/scroll")


  list_name = bewspweb_weave(type_element=By.XPATH,
      element="/html/body/div[1]/div[3]/div/div[2]/div[2]",
      type_subelement=By.XPATH,
      subelement="/html/body/div[1]/div[3]/div/div[2]/div[2]/div",
      selsubtag="a",
      subtag="title",
      tries=10)


  bewspweb_print(list=list_name, col_a=0, col_b=1)
  ```



  Distributed under the MIT License. See `LICENSE` for more information.



  - **Email:** [andradeswork@gmail.com](mailto:andradewswork@gmail.com)


pkgId: 380c9e28fb20db9fcb1cc9b8ae68d09d6a5127cea8fb6e36b9f6721919736e6f
name: python-beyond
arch: src
version: 0.7.5
epoch: 0
release: 1
summary: Flight Dynamic Library
url: https://github.com/galactics/beyond
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beyond-0.7.5-1.src.rpm
checksum_type: sha256
description:
  This library was started to better understand how Flight Dynamics works. It
  has no intent of efficiency nor performance at the moment, and the goal is
  mainly to develop a simple API for space observations.
  The sources of this library can be found at `github <https://github.com/galactics/beyond>`__ and
  are under the MIT license.


pkgId: 3c371f63b6df1a044622d6fba532d6bae2cda8680ea3bd2c44018fdced5f565a
name: python-bezalel
arch: src
version: 0.0.20
epoch: 0
release: 1
summary: A library for ingesting data provided by paginated HTTP APIs
url: https://pypi.org/project/bezalel/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bezalel-0.0.20-1.src.rpm
checksum_type: sha256
description:
  A library for ingesting data provided by paginated HTTP APIs






  If you have to pull data from HTTP API that has an endpoint accepting parameters:

  ```
  pageNumber=1,2,...
  ```

  And returning JSON:

  ```json
  {
      "pageCount": 5,
      "entities": [
        {"key":  "val1", ...},
        {"key":  "val2", ...},
        ...
      ]
  }
  ```

  Then you can iterate over all pages with following code:
  ```python
  import requests
  from bezalel import PaginatedApiIterator


  for page in PaginatedApiIterator(requests.Session(), url=f"http://localhost:5000/page-api",
                                       request_page_number_param_name="pageNumber",
                                       response_page_count_field_name="pageCount",
                                       response_records_field_name="entities"):
      print(f"Page: {page}")
  ```

  It will print:

  ```
  Page: [{"key":  "val1", ...}, {"key":  "val2", ...}, ...]
  Page: [{"key":  "val100", ...}, {"key":  "val101", ...}, ...]
  Page: [{"key":  "val200", ...}, {"key":  "val201", ...}, ...]
  ...
  ```




  If HTTP API doesn't allow you setting high number of records per page, use `BufferingIterator`.

  ```python
  import requests
  from bezalel import PaginatedApiIterator, BufferingIterator


  for page in BufferingIterator(PaginatedApiIterator(requests.Session(), url=f"http://localhost:5000/page-api",
                                                         request_page_number_param_name="pageNumber",
                                                         response_page_count_field_name="pageCount",
                                                         response_records_field_name="entities"), buffer_size=2):
      print(f"Page: {page}")
  ```

  It will combine multiple pages into one array, so that
  ```
  Page: [{"key":  "val1", ...}, {"key":  "val2", ...}, ..., {"key":  "val100", ...}, {"key":  "val101", ...}, ...]
  Page: [{"key":  "val200", ...}, {"key":  "val201", ...}, ..., {"key":  "val300", ...}, {"key":  "val301", ...}, ...]
  ...
  ```

  This is useful for fetching many records and storing them in fewer files (every file would be bigger).




  TODO: this API will be improved in future release.

  ```python
  import itertools
  import requests
  from bezalel import PaginatedApiIterator


  all_elems = list(itertools.chain.from_iterable(PaginatedApiIterator(requests.Session(), url=f"https://your/api",
                                                     request_page_number_param_name="pageNumber",
                                                     response_page_count_field_name="pageCount",
                                                     response_records_field_name="entities"))):
  print(f"len={len(all_elems)}: {all_elems}")
  ```

  will print

  ```
  len=12300: [{"key":  "val1", ...}, {"key":  "val2", ...}, ...]
  ```



  Normalize python dict, so that it has all the fields and only the fields specified in a prototype dict.

  ```python
  from bezalel import normalize_with_prototype

  object_from_api = {
      "id": 123,
      "name:": "John",
      "country": "Poland",
      "customDict": {
          "some": 123,
          "complex": 345,
          "structure": 546
      },
      
      "pets": [
          {"id": 101, "type": "dog", "name": "Barky"},
          {"id": 102, "type": "snail"},   # name is not provided here (but present in prototype)
      ],
      "unspecifiedField": 123     # this field is not present in prototype below
  }

  prototype_from_swagger = {
      "id": 0,
      "name:": "",
      "country": "",
      "customDict": {},
      "city": "",
      "pets": [
          {"id": 0, "type": "", "name": ""},
      ]
  }

  result = normalize_with_prototype(prototype_from_swagger, object_from_api, pass_through_paths=[".customDict"])

  ```

  would return

  ```python
  result = {
      "id": 123,
      "name:": "John",
      "country": "Poland",
      "customDict": {
          "some": 123,
          "complex": 345,
          "structure": 546
      },
      "city": None,   # city was added
      "pets": [
          {"id": 101, "type": "dog", "name": "Barky"},
          {"id": 102, "type": "snail", "name": None}, # name was added
      ]
  }
  ```




  Normalize list of nested python dicts to a list of one-level dicts.

  Example:
  ```python
  from bezalel import normalize_dicts

  data = [
      {
          "id": 1, "name": "John Smith",
          "pets": [
              {"id": 101, "type": "cat", "name": "Kitty", "toys": [{"name": "toy1"}, {"name": "toy2"}]},
              {"id": 102, "type": "dog", "name": "Barky", "toys": [{"name": "toy3"}]}
          ]
      },
      {
          "id": 2, "name": "Sue Smith",
          "pets": [
              {"id": 201, "type": "cat", "name": "Kitten", "toys": [{"name": "toy4"}, {"name": "toy5"}, {"name": "toy6"}]},
              {"id": 202, "type": "dog", "name": "Fury", "toys": []}
          ]
      },
  ]

  normalize_dicts(data, ["pets", "toys"])
  ```

  would return:

  ```python
  [{'id': 1, 'name': 'John Smith', 'pets.id': 101, 'pets.type': 'cat', 'pets.name': 'Kitty', 'pets.toys.name': 'toy1'},
   {'id': 1, 'name': 'John Smith', 'pets.id': 101, 'pets.type': 'cat', 'pets.name': 'Kitty', 'pets.toys.name': 'toy2'},
   {'id': 1, 'name': 'John Smith', 'pets.id': 102, 'pets.type': 'dog', 'pets.name': 'Barky', 'pets.toys.name': 'toy3'},
   {'id': 2, 'name': 'Sue Smith', 'pets.id': 201, 'pets.type': 'cat', 'pets.name': 'Kitten', 'pets.toys.name': 'toy4'},
   {'id': 2, 'name': 'Sue Smith', 'pets.id': 201, 'pets.type': 'cat', 'pets.name': 'Kitten', 'pets.toys.name': 'toy5'},
   {'id': 2, 'name': 'Sue Smith', 'pets.id': 201, 'pets.type': 'cat', 'pets.name': 'Kitten', 'pets.toys.name': 'toy6'},
   {'id': 2, 'name': 'Sue Smith', 'pets.id': 202, 'pets.type': 'dog', 'pets.name': 'Fury'}]
  ```

  Presence of the last record can be controlled by flag `return_incomplete_records`. If `return_incomplete_records=False`
  then last record in the example would not have been returned.

  Additional options:
  - jsonify_lists - when set to True, then if a list is encountered (not in main path), it is dumped as a JSON string.
  - jsonify_dicts - list of paths for where to expect a dict. That dict will be then dumped as a JSON string.


pkgId: 9c11c7e5c34af6e3d1abe60930e683de6644ab2666e6db885bef3af6c958c107
name: python-bezier-interpolation
arch: src
version: 0.0.2
epoch: 0
release: 1
url: https://github.com/balexandermunoz/bezier-interpolation
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bezier-interpolation-0.0.2-1.src.rpm
checksum_type: sha256
summary:
  A Python library for generating smooth curves between given points using cubic and quadratic Bezier interpolation.

description:
  `bezier_interpolation` is a Python library for generating smooth curves between given points using cubic Bezier or quadratic interpolation.

  It solves a specific problem: Calculate the optimal control points between two data points to have smooth bezier curves.

  It provides a simple and efficient way to calculate the control points and interpolate the data, making it ideal for applications in computer graphics, data visualization, and other fields where smooth curves are required.




  ```sh
  pip install bezier_interpolation
  ```


  ```python
  from bezier_interpolation import cubic_interpolation, quadratic_interpolation

  c_data = {"x": [1, 2, 3], "y": [-1, -5, 3]}
  c_data = list(zip(c_data["x"], c_data["y"]))
  c_interpolated_data = cubic_interpolation(c_data)
  print(c_interpolated_data)


  q_data = [(1, 1), (2, 4), (3, 9)]
  q_interpolated_data = quadratic_interpolation(q_data)
  print(q_interpolated_data)


  ```




  Let's say we have this 3 green points $P_{0,0}$, $P_{3,0} = P_{0,1}$ and $P_{3,1}$ and we want to have a smooth curve between them.
  ![Cubic Bezier Interpolation](https://github.com/balexandermunoz/bezier-interpolation/blob/master/bezier-interpolation.png?raw=true)

  We need to find where to set the control points $P_{1,0}$, $P_{2,0}$, $P_{1,1}$ and $P_{2,1}$.

  Here the first index represent the point and the second represent the segment.
  In general we have n points, n - 1 segments, and we need to find $P_{1,i}$ and $P_{2,i}$ control points for i $\in [0, n - 1]$

  For that we need to set two conditions:
  1. The last point in one segment $P_{3,i}$ is equal to the start point in the next segment $P_{0, i + 1}$.
  2. To get a smooth curve we need to make sure the slope of the line connecting $P_{2,0}$ and $P_{3,0}$ is the same as $P_{3,0}$ and $P_{0,1}$.


  We can write the first condition as
  $$
  \begin{align}
  P_{0,i} = P_{3,i - 1} = K_i
  \end{align}
  $$

  For the second condition we are goint to use derivatives. The first derivative of any polynomial curve is the slope, so let's derivate the equation for a cubic Bezier curve:

  $$
  \begin{align}
  B(t) = (1 - t)^3 \cdot P_0 + 3(1 - t)^2t \cdot P_1 + 3(1 - t)t^2 \cdot P_2 + t^3 \cdot P_3
  \end{align}
  $$

  Ant its first derivative:

  $$
  \begin{align}
  B'(t) = 3(1 - t)^2 \cdot (P_1 - P_0) + 6(1 - t)t \cdot (P_2 - P_1) + 3t^2 \cdot (P_3 - P_2)
  \end{align}
  $$

  By definition, if we replace $t = 0$ in $B(t)$ we get $B(0) = P_0$ and $B(1) = P_3$, so, to meet our condition we can write $$B'_i(0) = B'_{i-1}(1)$$

  If we replace the values in the equation, we get:

  $$-3P_{0,i} + 3P_{1, i} = -3 P_{2,i-1} + 3 P_{3, i-1}$$

  And using the eq (1):
  $$
  \begin{align}
  2K_i = P_{1,i} + P_{2, i-1}
  \end{align}
  $$

  We will now move to the second derivative. The second derivative tells us about the continuity of the curve. The second derivative of the bezier curve is:

  $$
  \begin{align}
  B''(t) = 6(1 - t) \cdot (P_2 - 2P_1 + P_0) + 6t \cdot (P_3 - 2P_2 + P_1)
  \end{align}
  $$

  The second derivative talks about the continuity and concavity of the plot.
  So, we can write:
  $$B''_i(0) = B''_{i-1}(1)$$

  If we substitute again we get:
  $$ -2P_{1,i} + P_{2,i} = P_{1, i - 1} - 2P_{2, i - 1} $$

  Those equations only apply in the internal knots, when the segments come together. So, let's get the equations for the boundaries, this is, $i = 0$ and $i = n - 1$:

  $$B''_i(0) = 6P_{0,0} - 12 P_{1,0} + 6P_{2,0}  $$

  $$ K_0 - 2P_{1,0} + P_{2,0} = 0  $$

  and:

  $$ P_{1,n-1} - P_{2,n-1} + K_n= 0  $$

  now we have:

  $$ 2P_{1,0} + P_{1,1} = K_0 + 2K_1 $$
  $$ P_{1,i-1} + 4P_{1,i} + P_{1, i+1} = 4K_i + 2K_{i+1} $$
  $$ 2P_{1,n-2} + P_{1,n-1} = 8K_{n-1} + K_n $$

  With those equations we can set a matrix system with the form Ax -b = 0, when A is a tri-diagonal matrix with this form:

  $$
  \begin{bmatrix}
  2 & 1 & 0 & 0 & \cdots & 0 \\
  1 & 4 & 1 & 0 & \cdots & 0 \\
  0 & 1 & 4 & 1 & \cdots & 0 \\
  \vdots & \vdots & \ddots & \ddots & \ddots & \vdots \\
  0 & 0 & \cdots & 1 & 4 & 1 \\
  0 & 0 & \cdots & 0 & 2 & 7
  \end{bmatrix}
  $$

  x is this vector:
  $$
  \begin{bmatrix}
  P_{1,1} \\
  P_{1,2} \\
  P_{1,3} \\
  \vdots \\
  P_{1,n-2} \\
  P_{1, n-1}
  \end{bmatrix}
  $$

  and b this one:
  $$
  \begin{bmatrix}
  K_{0} + 2K_1  \\
  4K_0 + 2K_1  \\
  4K_1 + 2K_2  \\
  \vdots  \\
  4K_{n-2} + 2K_{n-1}  \\
  8K_{n-1} + K_{n}
  \end{bmatrix}
  $$

  and if we solve this system, we can get $P_{2}$ with:

  $$P_{2, i} = 2K_i + P_{1,i}$$
  and
  $$P_{2, n-1} = (1/2)(K_n + P_{1,n-1})$$


  We could follow a process similar to the one we did above, but this one would be straightforward and it will have no dependency with t. We want to control the start angle, so let's try a geomterical approach.
  Let's suppose we now want just one control point between two data points, so we have something like this
  ![Quadratic Bezier Interpolation](https://github.com/balexandermunoz/bezier-interpolation/blob/master/bezier-interpolation2.png?raw=true)
  Did you notice that now we need points $P_{1,0}$ and $P_{1,1}$ in the same line?
  In general, we need $P_{1, i}$ align for $i \in 0,1,...,n-1$ when $n$ = number of data points, and $n-1$ is the number of segments.

  We are going to set the first control point in the middle of $P_{0,0}$ and $P_{0,2}$, so, we can say for the midpoint formula:

  $$ P_{0,1} = P_{0,0} + \frac{1}{2}(P_{0, 2} - P_{0,0}) $$

  If we want to add the control parameter $t$, we can control the distance and relative altitude respect the last point, so we write

  $$ P_{0,1} = P_{0,0} + t (P_{0, 2} - P_{0,0}) $$

  Now that we have the first control point, we need to compute the line between $P_{0,1}$ and $P_{0,2}$ and set the next control point in that line.

  We call the line between $P_{i,1}$ and $P_{i,2}$ $L_{i}$ which is defined by the equation $Y_i = m_i  X_{i-1} + b_i$.
  $Y_i$ is the $Y$ component of $P_{i,1}$ and  $X_{i-1}$ is the $X$ component of $P_{i-1,1}$.

  So, in general, for the next $n-2$ points we can write:
  $$m_i = \frac{Y_{i, 0} - Y_{i-1, 1}}{X_{i, 0} - X_{i-1, 1}}$$

  $$b_i = Y_{i, 0} - m_i X_{i, 0} $$

  and

  $$X_{i,1} = X_{i,0} + \frac{1}{2}(x_{i,2} - X_{i,0})$$

  $$Y_{i,1} = m_i  X_{i,1} + b_i$$

  wich are the X,Y components of the desired $P_{i,1}$  point respectively.

  - [Smooth Bezier Spiline Through Prescribed Points](https://www.particleincell.com/2012/bezier-splines/)

  - [Drawing Smooth Cubic Bezier Curve through prescribed points](https://exploringswift.com/blog/Drawing-Smooth-Cubic-Bezier-Curve-through-prescribed-points-using-Swift)


pkgId: 2063b5ccb5de1670c7b95ae8456a45233090564ff49cce2533a769ea588763fc
name: python-beziers
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Bezier curve manipulation library
url: https://github.com/simoncozens/beziers.py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beziers-0.6.0-1.src.rpm
checksum_type: sha256
description:
  Beziers provides a variety of classes for constructing, manipulating and
  drawing Bezier curves and paths. Principally designed for font design
  software, it allows you to join, split, offset, and perform many other
  operations on paths.
  Here is an example session::
      from beziers.point import Point
      from beziers.path import BezierPath
      from beziers.cubicbezier import CubicBezier
      b1 = CubicBezier(
        Point(412.0,500.0), Point(308.0,665.0), Point(163.0,589.0), Point(163.0,504.0)
      )
      b2 = CubicBezier(
        Point(163.0,504.0), Point(163.0,424.0), Point(364.0,321.0), Point(366.0,216.0)
      )
      b3 = CubicBezier(
        Point(366.0,216.0), Point(368.0,94.0), Point(260.0,54.0), Point(124.0,54.0)
      )
      path = BezierPath.fromSegments([b1,b2,b3])
      path.closed = False
      path.addExtremes()
      path.balance()
      path.translate(Point(-100.0,-100.0))
      import matplotlib.pyplot as plt
      fig, ax = plt.subplots()
      path.addExtremes()
      path.plot(ax)
      plt.show()
  Full documentation is available at https://simoncozens.github.io/beziers.py/index.html


pkgId: 057a33b2d5e99864cd009a88a870aa479c35a1526552940725f57c44efeaa893
name: python-bezzanlabs.treemachine
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: An AutoML companion to fit tree models easily
url: https://github.com/vitorbezzan/tree_machine
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bezzanlabs.treemachine-1.2.3-1.src.rpm
checksum_type: sha256
description:
  [![python](https://img.shields.io/badge/python-3.11-blue?style=for-the-badge)](http://python.org)
  [![python](https://img.shields.io/badge/python-3.12-red?style=for-the-badge)](http://python.org)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow?style=for-the-badge)](https://opensource.org/licenses/MIT)

  This package aims to give users a simple interface to fit tree models. Tree models are
  the workhorse for tabular data and are used in many applications. Our aim is to simplify
  the use, tuning and deployment of these models.


  Specific auto-tune trees that use Bayesian optimization to select the best model overall
  and the best hyperparameters for that model. The models are trained using a `lightgbm`
  backend, and the user can change the parameters to use during `fit`.

  Can be used as a last step inside a `sklearn.pipeline` object.



  Just issue the command:

  ```bash
  python -m pip install bezzanlabs.treemachine
  ```

  This package should work in all systems, and it was tested in Linux and MacOS.



  To install this package, run the following command in your terminal:
  ```bash
  make install
  ```
  This should proceed with the installation of all dependencies for development.


pkgId: c98596a177c8e739b741bee9e335e70589f325b4d75f2f433c2f584ea7764cb5
name: python-bfcm
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A library that quantifies implicit bias in tabular data with Fuzzy Cognitive Maps
url: https://pypi.org/project/bfcm/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bfcm-0.1.1-1.src.rpm
checksum_type: sha256
description:
  This python package includes the functions related to the papers "Modeling implicit bias with fuzzy cognitive maps" (Nápoles et al., 2022) and "Measuring Implicit Bias Using SHAP Feature Importance and Fuzzy Cognitive Maps" (Grau et al., 2023). An additional method included is using clustering to automatically discover the groups describing a numeric feature, which allows computing the association between numeric and categorical features using Cramer's V coefficient.
  The following people were involved in creating this package: Isel Grau, Gonzalo Nápoles, Leonardo Concepción, Fabian Hoitsma, Lisa Koutsoviti, João Paulo Papa, Koen Vanhoof


pkgId: 394465418b15f38238cf2befbea43d8d58d11417d906fa2756236e5a7edc9854
name: python-bfee2
arch: src
version: 2.5.0
epoch: 0
release: 1
summary: Binding Free Energy Estimator 2
url: https://github.com/fhh2626/BFEE2
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bfee2-2.5.0-1.src.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/322234705.svg)](https://zenodo.org/badge/latestdoi/322234705)

  Binding free energy estimator (BFEE) is a python-based software that automates absolute binding free energy calculations through either the alchemical or geometric route by molecular dynamics simulations.<br>


  The degrees of freedom of the protein-ligand (or host-guest) system are described by a series of geometric variables (or collective variables), as firstly described by the [Karplus group](https://pubs.acs.org/doi/abs/10.1021/jp0217839). In BFEE, a generalized, best-fit-rotation-based geometric variables are used, making it in principle available to any protein-ligand complex. See [this paper](https://pubs.acs.org/doi/abs/10.1021/acs.jctc.7b00791) for introduction of these variables.<br>

  In the [geometric route](https://pubs.acs.org/doi/10.1021/ct3008099), the degrees of freedom is investigated one by one, through one-dimensional free-energy calculations. In BFEE, [WTM-eABF](https://pubs.acs.org/doi/abs/10.1021/acs.accounts.9b00473) is used, while other importance-sampling algorithms such as [plain eABF](https://pubs.acs.org/doi/abs/10.1021/acs.jctc.6b00447) are also acceptable.
  The [alchemical route](https://pubs.acs.org/doi/10.1021/ct3008099) is a variants of the [double decoupling method (DDM)](https://www.sciencedirect.com/science/article/pii/S0006349597787563). A thermodynamic cycle, in which the ligand and the geometric restraints are decoupled independently to guarantee the convergence of the simulations.<br>
  [这里](http://sioc-journal.cn/Jwk_hxxb/CN/10.6023/A20100489)是标准结合自由能计算方法的中文介绍.<br>


  Generates all the input files for absolute binding free energy calculations;<br>
  Perform post-treatment automatedly;<br>
  Support NAMD (alchemical and geometric route) and Gromacs (geometric route) as molecular dynamics engines;<br>
  Support many file formats for the input complex structure (PSF/PDB/PRM, PRM7/RST7, TOP/PDB);<br>
  Support both rigid (exclude RMSD CV) and flexible (include RMSD CV) ligands and protein-protein complexes (streamlined geometrical route);<br>
  ...<br>


  Python 3.6+, PySide 2, numpy, scipy, matplotlib, parmed and MDAnalysis.<br>
  [NAMD 3.0 or later](https://www.ks.uiuc.edu/Development/Download/download.cgi?PackageName=NAMD) / [Colvars patched Gromacs](https://github.com/Colvars/colvars).<br>
  **Note: BFEE2 uses cutting-edge features of NAMD and Colvars. We highly suggest the end-user download the devel branch of NAMD from [here](https://gitlab.com/tcbgUIUC/namd/-/tree/devel) and patch it with [Colvars](https://github.com/Colvars/colvars) to prevent possible problems.**


  We suggest to install BFEE2 through conda. It will be safe if conda is install in a new environment<br>
  ```
  conda create --name bfee   (optional)
  conda activate bfee        (optional)
  conda install -c conda-forge BFEE2
  ```


  Simply run BFEE2Gui.py in terminal or PowerShell. One may need to use the absolute path on MS Windows.<br>
  A step-by-step tutorial is provided [here](https://www.nature.com/articles/s41596-021-00676-1).<br>
  A tutorial about new streamlined geometrical route is provided in the SI of [this paper](https://pubs.acs.org/doi/full/10.1021/acs.jcim.3c00487).<br>


  When possible, please consider mentioning [Fu et al. Nat. Protoc. 2022, doi:10.1038/s41596-021-00676-1](https://www.nature.com/articles/s41596-021-00676-1#citeas) when BFEE2 is used in your project.


  Additional references:<br>
  BFEE2: [Fu et al. J. Chem. Inf. Model. 2021, 61, 2116–2123](https://pubs.acs.org/doi/abs/10.1021/acs.jcim.1c00269)<br>
  Alchemical and geometric routes [Gumbart et al. J. Chem. Theory Comput. 2013, 9, 794–802](https://pubs.acs.org/doi/abs/10.1021/ct3008099)<br>
  WTM-eABF: [Fu et al. Acc. Chem. Res. 2019, 52, 3254–3264](https://pubs.acs.org/doi/abs/10.1021/acs.accounts.9b00473) and [Fu et al. J. Phys. Chem. Lett. 2018, 9, 4738–4745](https://pubs.acs.org/doi/abs/10.1021/acs.jpclett.8b01994)<br>
  Collective variables: [Fu et al. J. Chem. Theory Comput. 2017, 13, 5173–5178](https://pubs.acs.org/doi/abs/10.1021/acs.jctc.7b00791)<br>
  Colvars module: [Fiorin et al. Mol. Phys. 2013 111, 3345-3362](https://www.tandfonline.com/doi/full/10.1080/00268976.2013.813594)<br>
  "Mother" of all restraint-based binding free-energy calculations: [Hermans et al. Isr. J. Chem. 1986, 27, 225–227](https://onlinelibrary.wiley.com/doi/abs/10.1002/ijch.198600032)<br>


  Technique issues: Haohao Fu (fhh2626@mail.nankai.edu.cn) and Haochuan Chen (yjcoshc@mail.nankai.edu.cn)<br>

  This software is under the [GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html) license. For more information about the copyright of BFEE, contact the corresponding authors of the aforementioned papers (wscai@nankai.edu.cn, Christophe.Chipot@univ-lorraine.fr).


pkgId: d4358e454597d94fc06bb6b7bb0c70bf1e31cfd0dcdc97348793555d0bffd233
name: python-bfet
arch: src
version: 0.1.11
epoch: 0
release: 1
url: https://github.com/lluc2397/bfet
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bfet-0.1.11-1.src.rpm
checksum_type: sha256
summary:
  Better Faster Easier Testing. Create Django models quickly and easly, create different data types for testing cases or create default tests files


pkgId: a76de8c5efef1062ffc2a15523fc6d8abe5b164e71a5611a46e2d04590727963
name: python-bfg-friendly
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: Friendly CLI tool for removing sensitive data from a repository
url: https://github.com/34j/bfg-friendly
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bfg-friendly-0.0.7-1.src.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://bfg-friendly.readthedocs.io" target="_blank">https://bfg-friendly.readthedocs.io </a>


pkgId: 5208aec663354a56c22c98ea337f0cd3390bdbabc3c5bb71de4c0795ceaf7eeb
name: python-bfg9000
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: A cross-platform build file generator
url: https://jimporter.github.io/bfg9000/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bfg9000-0.7.1-1.src.rpm
checksum_type: sha256
description:
  **bfg9000** is a cross-platform *build configuration system* with an emphasis on
  making it easy to define how to build your software. It converts a Python-based
  build script into the appropriate files for your underlying build system of
  choice (Ninja, Make, or MSBuild).





  `build.bfg` files are just Python scripts with some new functions added, so you
  may already know how to write them; and when your build gets complicated, you
  can rely on the existing Python ecosystem to get you out of trouble.



  bfg9000 ensures your builds are fast by relying on existing, mature build
  systems like Make and Ninja to do the heavy lifting of building your software;
  often, incremental builds don't need to execute bfg9000 at all!



  Building your code shouldn't be the hard part of developing your project. Above
  all else, bfg9000 strives to help you get your build right the *first* time with
  many helpful [features][features].



  You can't get much simpler than the simplest `build.bfg` file:

  ```python
  executable('simple', files=['simple.cpp'])
  ```

  To build this executable, we need to create the actual build files and then
  run them:

  ```sh
  $ cd /path/to/src/
  $ 9k build/
  $ cd build/
  $ ninja
  ```

  From there, you can run your newly-created executable: `./simple`. Hooray!

  For further examples, please see the [`examples/`][examples] subdirectory.



  bfg9000 uses [setuptools][setuptools], so installation is much the same as any
  other Python package:

  ```sh
  $ pip install bfg9000
  ```

  From there, you can start using bfg to build your software! (If you're using
  Ubuntu, you can also install bfg9000 from the following PPA:
  [ppa:jimporter/stable][ppa]). For more information about how to install bfg9000,
  see the [documentation][getting-started].



  This project is licensed under the [BSD 3-clause license](LICENSE).

  [pypi-image]: https://img.shields.io/pypi/v/bfg9000.svg
  [pypi-link]: https://pypi.python.org/pypi/bfg9000
  [documentation-image]: https://img.shields.io/badge/docs-bfg9000-blue.svg
  [documentation-link]: https://jimporter.github.io/bfg9000/
  [gh-actions-image]: https://github.com/jimporter/bfg9000/workflows/build/badge.svg
  [gh-actions-link]: https://github.com/jimporter/bfg9000/actions?query=branch%3Amaster+workflow%3Abuild
  [appveyor-image]: https://ci.appveyor.com/api/projects/status/hxvbggf6exq8i2k6/branch/master?svg=true
  [appveyor-link]: https://ci.appveyor.com/project/jimporter/bfg9000/branch/master
  [codecov-image]: https://codecov.io/gh/jimporter/bfg9000/branch/master/graph/badge.svg
  [codecov-link]: https://codecov.io/gh/jimporter/bfg9000

  [features]: https://jimporter.github.io/bfg9000/latest/user/features
  [examples]: https://github.com/jimporter/bfg9000/tree/master/examples
  [setuptools]: https://pythonhosted.org/setuptools/
  [ppa]: https://launchpad.net/~jimporter/+archive/ubuntu/stable
  [getting-started]: https://jimporter.github.io/bfg9000/latest/getting-started


pkgId: 50e96693c14f9a70d5fa01cf967d35d0b3408e61319ea2586e940dfed3d0a022
name: python-bfi
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: A fast optimizing Brainfuck interpreter in pure python
url: http://github.com/eriknyquist/bfi
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bfi-1.0.4-1.src.rpm
checksum_type: sha256
description:
  This is a pure python interpreter for the
  `Brainfuck <https://en.wikipedia.org/wiki/Brainfuck>`_ esoteric programming
  language. ``bfi`` is quite fast without requiring any special python implementations
  or compiled extension modules. ``bfi`` Supports Python 2x and 3x.
  ``bfi`` achieves a significant speedup in the execution of brainfuck
  programs by first compiling brainfuck source code into an intermediate form.
  This intermediate form takes advantage of common brainfuck programming constructs
  to execute much faster than if we were to interpret & execute the brainfuck source directly.
  Take moving the cell pointer, as a relativey simple example; to execute ``<<<<<<<<<<``,
  we could iterate over each ``<`` character, and perform 10 separate "cell pointer decrement"
  operations. This would be the slow option. Alternatively, we could collapse those 10 instructions
  into a single instruction to decrement the cell pointer by 10 in a single operation. This is
  generally how the opcodes for the intermediate form work. All runs of cell pointer
  increment/decrements are collapsed like this, as well as several other similar optimizations.


pkgId: a9812e11399d1e7636cf225a38eeadc1e1dfcf914a34c2ec8614b3c1176217a2
name: python-bfjira
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Create Git branches from Jira tickets
url: https://pypi.org/project/bfjira/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bfjira-0.5.0-1.src.rpm
checksum_type: sha256
description:
  ![PyPI - Version](https://img.shields.io/pypi/v/bfjira)




  bfjira (branch from Jira) is a command-line utility that simplifies the process of creating Git branches based on JIRA ticket information. It ensures that branch names are consistent and informative by incorporating the issue type and summary from the JIRA ticket.



  The recommended way to install bfjira is via `pip` from PyPI:

  ```bash
  pip install bfjira
  ```

  Make sure you have `pip` installed and are using a virtual environment if necessary.



  To use bfjira, you must have the following environment variables set:

  - `JIRA_SERVER`: Your JIRA server URL.
  - `JIRA_EMAIL`: The email address associated with your JIRA account.
  - `JIRA_API_TOKEN`: Your JIRA API token.

  Instructions for creating a Jira API token can be found [here](https://support.atlassian.com/atlassian-account/docs/manage-api-tokens-for-your-atlassian-account/)

  Optionally, you can set the `JIRA_TICKET_PREFIX` environment variable to use a default prefix other than "SRE" for ticket IDs that are entered without a prefix.



  - Show help message:

    ```bash
    bfjira --help
    ```

  - Create a branch for a JIRA ticket:

    ```bash
    bfjira --ticket SRE-1234
    ```

    If you only have the ticket number, bfjira will use the default prefix ("SRE" or whatever is set in `JIRA_TICKET_PREFIX`):

    ```bash
    bfjira -t 1234
    ```



  - Set a custom issue type for the branch:

    ```bash
    bfjira -t 1234 --issue-type hotfix
    ```

  - Create a branch without setting the upstream:

    ```bash
    bfjira -t 1234 --no-upstream
    ```

  - Increase output verbosity (useful for debugging):

    ```bash
    bfjira -t 1234 -v
    ```

  - Optionally prevent transitioning the ticket to 'In Progress':

    By default, the script transitions the specified JIRA ticket to 'In Progress'. If you wish to create a branch for the ticket without changing its status, use the `--no-progress` flag. This is useful when you need to perform operations on the ticket without indicating that work has started.

    ```bash
    bfjira -t 1234 --no-progress
    ```



  Contributions to bfjira are welcome! Please read the contributing guidelines before submitting pull requests.



  bfjira is released under the GNU General Public License. See the [LICENSE](LICENSE) file for more details.


pkgId: 3473eaf85fb97ff47dda7dedabefebb341ce124a83930f2122aa7f38dcccc4a8
name: python-bflb-iot-tool
arch: src
version: 1.9.0
epoch: 0
release: 1
summary: Bouffalolab Iot Tool
url: https://pypi.org/project/bflb-iot-tool/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bflb-iot-tool-1.9.0-1.src.rpm
checksum_type: sha256
description:
  The functions of bflb_iot_tool is the same as DevCube(IOT View) which is a GUI tool for image programing.
  bflb_iot_tool is designed for the convenience of integrating into the compilation system after image buid,
  and making it more easy for users who are accustomed to using command line operations.

  * --chipname：mandatory, name of chip(bl602/bl702/bl616...)
  * --interface：1.uart, 2.jlink, 3.cklink, 4.openocd, default is uart
  * --port：serial port or jlink serial number
  * --baudrate：baudrate of serial port, default is 115200
  * --xtal：xtal on the board, for bl602,1:24M,2:32M,3:38.4M,4:40M(default value when not specified),5:26M; for bl702,1:32M(default value when not specified); for bl616,just use value 7(auto adjust)
  * --config：eflash loader configuration file, default is chips/blXXXX/eflash_loader/eflash_loader_cfg.ini
  * --ota：dir of ota file, default is chips/blXXXX/ota

  1.scattered files:
  * --firmware：mandatory, select the firmware binary file which your sdk build out
  * --dts：optional, select the device tree file you used
  * --pt：mandatory, partition table of flash, default is located in chips/chipname/partition
  * --boot2：mandatory,boot2 binary file as bootloader, default is located in chips/chipname/builtin_imgs/boot2_isp_xxxxx
  * --mfg：optional, mfg binary file, only use when do RF test
  * --romfs：optional, romfs dir to create romfs.bin
  2.one whole image file:
  * --addr：address to program, default is 0
  * --single：the single file to be programmed, the tool will add nothing for this file

  * --build：build image only,not program into flash
  * --key：aes encrypt key
  * --iv：aes encrypt iv
  * --pk：ecc sign public key
  * --sk: ecc sign private key

  * bflb_iot_tool.exe --chipname=bl602 --port=COM28 --baudrate=2000000 --firmware="helloworld_bl602.bin" --pt="chips/bl602/partition/partition_cfg_2M.toml" --dts="chips/bl602/device_tree/bl_factory_params_IoTKitA_40M.dts"
  * bflb_iot_tool.exe --chipname=bl602 --port=COM28 --baudrate=2000000 --firmware="helloworld_bl602.bin" --pt="chips/bl602/partition/partition_cfg_2M.toml" --dts="chips/bl602/device_tree/bl_factory_params_IoTKitA_40M.dts" --build
  * bflb_iot_tool.exe --chipname=bl602 --port=COM28 --baudrate=2000000 --addr=0x0 --firmware="helloworld_bl602.bin" --single


pkgId: a7a01dc057312c8734ab13bf8d61afc494340230aa3aa53b1baccc392b3179b4
name: python-bflb-mcu-tool
arch: src
version: 1.9.0
epoch: 0
release: 1
summary: Bouffalolab Mcu Tool
url: https://pypi.org/project/bflb-mcu-tool/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bflb-mcu-tool-1.9.0-1.src.rpm
checksum_type: sha256
description:
  The functions of bflb_mcu_tool is the same as DevCube(MCU View) which is a GUI tool for image programing.
  bflb_mcu_tool is designed for the convenience of integrating into the compilation system after image buid,
  and making it more easy for users who are accustomed to using command line operations.

  * --chipname：mandatory, name of chip(bl602/bl702/bl616...)
  * --interface：1.uart, 2.jlink, 3.cklink, 4.openocd, default is uart
  * --bootsrc：1.flash, 2.uart/sdio, 3.uart/usb, default is flash
  * --port：serial port or jlink serial number
  * --baudrate：baudrate of serial port, default is 115200
  * --xtal：xtal on the board, for bl602,1:24M,2:32M,3:38.4M,4:40M(default value when not specified),5:26M; for bl702,1:32M(default value when not specified); for bl616,just use value 7(auto adjust)
  * --config：eflash loader configuration file,default is chips/blXXXX/eflash_loader/eflash_loader_cfg.ini
  * --flashclk：clock of flash
  * --pllclk：clock of pll

  * --firmware：mandatory, select the firmware binary file which your sdk build out
  * --dts：optional,select the device tree file you used
  * --addr：address to program, default is 0x2000
  * --erase：erase the whole flash

  * --build：build image only

  * bflb_mcu_tool.exe --chipname=bl602 --port=COM28 --baudrate=2000000 --firmware="helloworld_bl602.bin"
  * bflb_mcu_tool.exe --chipname=bl602 --port=COM28 --baudrate=2000000 --firmware="helloworld_bl602.bin" --erase
  * bflb_mcu_tool.exe --chipname=bl602 --port=COM28 --baudrate=2000000 --firmware="helloworld_bl602.bin" --build


pkgId: 7c3a8692c4ca0dcb8098ca2101b02dc34ad57822e33e552bd093dc2a7fbd8c11
name: python-bfqry
arch: src
version: 2024.12.1
epoch: 0
release: 1
summary: Batfish Query Utility
url: https://pypi.org/project/bfqry/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bfqry-2024.12.1-1.src.rpm
checksum_type: sha256
description:
  - [Installation](#installation)
  - [License](#license)

  ```console
  pip install bfqry
  ```

  - [argcomplete](https://pypi.org/project/argcomplete/)
  - [openpyxl](https://pypi.org/project/openpyxl/)
  - [pybatfish](https://pypi.org/project/pybatfish/)
  - [requests](https://pypi.org/project/requests/)
  - [setuptools](https://pypi.org/project/setuptools/)

  `bfqry` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.


pkgId: a443461e341aadc6be09ec3c5cadbecaf0eb3b61093ecd22bf70367925ced935
name: python-bg-atlasapi
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: A lightweight python module to interact with atlases for systems neuroscience
url: https://brainglobe.info/documentation/bg-atlasapi/index.html
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bg-atlasapi-1.0.3-1.src.rpm
checksum_type: sha256
description:
  [![Python Version](https://img.shields.io/pypi/pyversions/bg-atlasapi.svg)](https://pypi.org/project/bg-atlasapi)
  [![PyPI](https://img.shields.io/pypi/v/bg-atlasapi.svg)](https://pypi.org/project/bg-atlasapi/)
  [![Wheel](https://img.shields.io/pypi/wheel/bg-atlasapi.svg)](https://pypi.org/project/bg-atlasapi)
  [![Development Status](https://img.shields.io/pypi/status/brainatlas-api.svg)](https://github.com/SainsburyWellcomeCentre/brainatlas-api)
  [![Downloads](https://pepy.tech/badge/bg-atlasapi)](https://pepy.tech/project/bg-atlasapi)
  [![Tests](https://img.shields.io/github/actions/workflow/status/brainglobe/bg-atlasapi/test_and_deploy.yml?branch=main)](
      https://github.com/brainglobe/bg-atlasapi/actions)
  [![codecov](https://codecov.io/gh/brainglobe/bg-atlasapi/branch/master/graph/badge.svg?token=WTFPFW0TE4)](https://codecov.io/gh/brainglobe/bg-atlasapi)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/python/black)
  [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
  [![DOI](https://joss.theoj.org/papers/10.21105/joss.02668/status.svg)](https://doi.org/10.21105/joss.02668)
  [![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
  [![Contributions](https://img.shields.io/badge/Contributions-Welcome-brightgreen.svg)](https://docs.brainglobe.info/cellfinder/contributing)
  [![Website](https://img.shields.io/website?up_message=online&url=https%3A%2F%2Fbrainglobe.info)](https://brainglobe.info/documentation/bg-atlasapi/index.html)
  [![Twitter](https://img.shields.io/twitter/follow/brain_globe?style=social)](https://twitter.com/brain_globe)


  The brainglobe atlas API (BG-AtlasAPI) provides a common interface for programmers to download and process brain atlas data from multiple sources.



  A number of atlases are in development, but those available currently are:
  * [Allen Mouse Brain Atlas](https://www.brain-map.org) at 10, 25, 50 and 100 micron resolutions
  * [Allen Human Brain Atlas](https://www.brain-map.org) at 100 micron resolution
  * [Max Planck Zebrafish Brain Atlas](http://fishatlas.neuro.mpg.de) at 1 micron resolution
  * [Enhanced and Unified Mouse Brain Atlas](https://kimlab.io/brain-map/atlas/) at 10, 25, 50 and 100 micron resolutions
  * [Smoothed version of the Kim et al. mouse reference atlas](https://doi.org/10.1016/j.celrep.2014.12.014) at 10, 25, 50 and 100 micron resolutions
  * [Gubra's LSFM mouse brain atlas](https://doi.org/10.1007/s12021-020-09490-8) at 20 micron resolution
  * [3D version of the Allen mouse spinal cord atlas](https://doi.org/10.1101/2021.05.06.443008) at 20 x 10 x 10 micron resolution
  * [AZBA: A 3D Adult Zebrafish Brain Atlas](https://doi.org/10.1101/2021.05.04.442625) at 4 micron resolution
  * [Waxholm Space atlas of the Sprague Dawley rat brain](https://doi.org/10.1016/j.neuroimage.2014.04.001) at 39 micron resolution
  * [3D Edge-Aware Refined Atlases Derived from the Allen Developing Mouse Brain Atlases](https://doi.org/10.7554/eLife.61408) (E13, E15, E18, P4, P14, P28 & P56)
  * [Princeton Mouse Brain Atlas](https://brainmaps.princeton.edu/2020/09/princeton-mouse-brain-atlas-links) at 20 micron resolution
  * [Kim Lab Developmental CCF (P56)](https://data.mendeley.com/datasets/2svx788ddf/1) at 10 micron resolution with 8 reference images - STP, LSFM (iDISCO) and MRI (a0, adc, dwo, fa, MTR, T2)


  BG-AtlasAPI works with Python >3.6, and can be installed from PyPI with:
  ```bash
  pip install bg-atlasapi
  ```


  Full information can be found in the [documentation](https://brainglobe.info/documentation/bg-atlasapi/index.html)

  **List of atlases**

  To see a list of atlases use `bg_atlasapi.show_atlases`
  ```python
  from bg_atlasapi import show_atlases
  show_atlases()













  ```

  **Using the atlases**

  All the features of each atlas can be accessed via the `BrainGlobeAtlas` class.


  e.g. for the 25um Allen Mouse Brain Atlas:

  ```python
  from bg_atlasapi.bg_atlas import BrainGlobeAtlas
  atlas = BrainGlobeAtlas("allen_mouse_25um")
  ```

  The various files associated with the atlas can then be accessed as attributes of the class:
  ```python

  reference_image = atlas.reference
  print(reference_image.shape)



  annotation_image = atlas.annotation
  print(annotation_image.shape)



  hemispheres_image = atlas.hemispheres
  print(hemispheres_image.shape)

  ```

  **Brain regions**

  There are multiple ways to work with individual brain regions. To see a dataframe of each brain region, with it's unique ID, acronym and full name, use `atlas.lookup_df`:
  ```python
  atlas.lookup_df.head(8)









  ```

  Each brain region can also be access by the acronym, e.g. for primary visual cortex (VISp):
  ```python
  from pprint import pprint
  VISp = atlas.structures["VISp"]
  pprint(VISp)







  ```


  Working with both image coordinates and cartesian coordinates in the same space can be confusing! In `bg-atlasapi`, the origin is always assumed to be in the upper left corner of the image (sectioning along the first dimension), the "ij" convention. This means that when plotting meshes and points using cartesian systems, you might encounter confusing behaviors coming from the fact that in cartesian plots one axis is inverted with respect to  ij coordinates (vertical axis increases going up, image row indexes increase going down). To make things as consistent as possible, in `bg-atlasapi` the 0 of the meshes coordinates is assumed to coincide with the 0 index of the images stack, and meshes coordinates increase following the direction stack indexes increase.
  To deal with transformations between your data space and `bg-atlasapi`, you might find the [brainglobe-space](https://github.com/brainglobe/brainglobe-space) package helpful.


  **Contributors to bg-atlaspi are absolutely encouraged**, whether you want to fix bugs, add/request new features or simply ask questions.

  If you would like to contribute to `bg-atlasapi` (or any of the downstream tools like [brainrender](https://github.com/brainglobe/brainrender) etc.) please get in touch by opening a new issue or pull request on [GitHub](https://github.com/brainglobe/bg-atlasapi). Please also see the [developers guide](https://brainglobe.info/developers/index.html).

  Someone might have already asked a question you might have, so if you're not sure where to start, check out the [issues](https://github.com/brainglobe/bg-atlasapi/issues) (and the issues of the other repositories).


  If you find the BrainGlobe Atlas API useful, please cite the paper in your work:

  >Claudi, F., Petrucco, L., Tyson, A. L., Branco, T., Margrie, T. W. and Portugues, R. (2020). BrainGlobe Atlas API: a common interface for neuroanatomical atlases. Journal of Open Source Software, 5(54), 2668, https://doi.org/10.21105/joss.02668

  **Don't forget to cite the developers of the atlas that you used!**

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


pkgId: 82dcd989262a15611dd840b75723de7a6b3cccc967bbd6558c98e5b3ad7047e3
name: python-bg-mpl-stylesheets
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: A package for using Billinge group Matplotlib style files.
url: https://github.com/Billingegroup/bg-mpl-stylesheets/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bg-mpl-stylesheets-0.5.1-1.src.rpm
checksum_type: sha256
description:
  |PyPi| |Forge| |PythonVersion| |PR|
  |CI| |Codecov| |Black| |Tracking|
  A package for using Billinge group Matplotlib style files.
  * bg-mpl-stylesheets is a Python software package that creates a standardized matplotlib figure format. This includes specialized fonts, figure border, color cycle, tick parameters, and more.


pkgId: db4a63d7f3e8b4ebeb518e23d5fbb68c1fd003d8f029a453fd93b36bea064bcb
name: python-bg4h
arch: src
version: 1.0.7
epoch: 0
release: 1
summary: bg table definitions for humans
url: https://pypi.org/project/bg4h/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bg4h-1.0.7-1.src.rpm
checksum_type: sha256
description:
  bee gees for Humans Table Definitions





  - added missing index field tarticulosavisos



  - added missing fields in ttareasavisos



  - added missing worker 1-3 fields -> tavisosreparacionesclientes



  - added missing fields
  - fix misspeling table ttrabajosavisos -> trabajosavisos



  - fixed spelling in vars of Personal table in BgMain



  - added missing fields from table vacaciones



  - added long description to setup.py
  - fixed ttarea6 -> to TTAREAS6



  - ts/net lib converted to python
  - spellfix
  - added todos for unknown / unclear values


pkgId: 1473a872c1813dd5f91c44c776b17215f8e0add69272c751b324e6ccb75f750c
name: python-bg4h
arch: src
version: 1.0.9
epoch: 0
release: 1
summary: bg table definitions for humans
url: https://pypi.org/project/bg4h/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bg4h-1.0.9-1.src.rpm
checksum_type: sha256
description:
  bee gees for Humans Table Definitions





  - fixed wrong defs on Inmovilizados
  - added defs for OtrosCostes and ValoresOtrosCostes



  - added new fields to `bg_soc.py`
  - fixed typos in `bg_main.py`
  - added missing field definitions in various tables



  - added missing index field tarticulosavisos



  - added missing fields in ttareasavisos



  - added missing worker 1-3 fields -> tavisosreparacionesclientes



  - added missing fields
  - fix misspeling table ttrabajosavisos -> trabajosavisos



  - fixed spelling in vars of Personal table in BgMain



  - added missing fields from table vacaciones



  - added long description to setup.py
  - fixed ttarea6 -> to TTAREAS6



  - ts/net lib converted to python
  - spellfix
  - added todos for unknown / unclear values


pkgId: 1c3ad927d71413d0277c2a1e86047549ede56c8d1654d3a2f7ec0ef5f69fa013
name: python-bgcflow_wrapper
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: A snakemake wrapper and utility tools command line interface for BGCFlow.
url: https://github.com/NBChub/bgcflow_wrapper
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bgcflow_wrapper-0.5.0-1.src.rpm
checksum_type: sha256
description:
  To install `bgcflow_wrapper` with conda/mamba, run this command in your
  terminal:
  ```bash

  mamba create -n bgcflow -c conda-forge python=3.11 pip openjdk -y
  conda activate bgcflow

  pip install bgcflow_wrapper
  ```


pkgId: 9d9a75d65023d1242d902f39131601c056f1a5d8cf0d49414e76e8a34c483a9a
name: python-bge-python-sdk
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: 可用于调用 BGE 开放平台的相关接口。
url: https://github.com/teambge/bge-python-sdk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bge-python-sdk-0.6.2-1.src.rpm
checksum_type: sha256
description:
  <div align="center">




  <p>
      <!-- Place this tag where you want the button to render. -->
      <a class="github-button" href="https://github.com/teambge/bge-python-sdk/subscription" data-color-scheme="no-preference: light; light: light; dark: dark;" data-show-count="true" aria-label="Watch teambge/bge-python-sdk on GitHub">
          <img alt="GitHub forks" src="https://img.shields.io/github/watchers/teambge/bge-python-sdk?style=social">
      </a>
      <a class="github-button" href="https://github.com/teambge/bge-python-sdk" data-color-scheme="no-preference: light; light: light; dark: dark;" data-show-count="true" aria-label="Star teambge/bge-python-sdk on GitHub">
          <img alt="GitHub forks" src="https://img.shields.io/github/stars/teambge/bge-python-sdk?style=social">
      </a>
      <a class="github-button" href="https://github.com/teambge/bge-python-sdk/fork" data-color-scheme="no-preference: light; light: light; dark: dark;" data-show-count="true" aria-label="Fork teambge/bge-python-sdk on GitHub">
          <img alt="GitHub forks" src="https://img.shields.io/github/forks/teambge/bge-python-sdk?style=social">
      </a>
  </p>

  <p>
      <img src="https://img.shields.io/github/v/release/teambge/bge-python-sdk" data-origin="https://img.shields.io/github/v/release/teambge/bge-python-sdk" alt="GitHub release (latest by date)">
      <img src="https://img.shields.io/github/languages/top/teambge/bge-python-sdk" data-origin="https://img.shields.io/github/languages/top/teambge/bge-python-sdk" alt="GitHub top language">
      <img src="https://img.shields.io/github/languages/code-size/teambge/bge-python-sdk" data-origin="https://img.shields.io/github/languages/code-size/teambge/bge-python-sdk" alt="GitHub code size in bytes">
      <img src="https://img.shields.io/github/commit-activity/w/teambge/bge-python-sdk" data-origin="https://img.shields.io/github/commit-activity/w/teambge/bge-python-sdk" alt="GitHub commit activity">
      <img src="https://static.pepy.tech/personalized-badge/bge-python-sdk?period=total&units=international_system&left_color=grey&right_color=blue&left_text=Downloads" data-origin="https://static.pepy.tech/personalized-badge/bge-python-sdk?period=total&units=international_system&left_color=grey&right_color=blue&left_text=Downloads" alt="PyPI - Downloads">
  </p>

  <pre>
      ____  ____________   ______  __________  ______  _   __   _____ ____  __ __
     / __ )/ ____/ ____/  / __ \ \/ /_  __/ / / / __ \/ | / /  / ___// __ \/ //_/
    / __  / / __/ __/    / /_/ /\  / / / / /_/ / / / /  |/ /   \__ \/ / / / ,<
   / /_/ / /_/ / /___   / ____/ / / / / / __  / /_/ / /|  /   ___/ / /_/ / /| |
  /_____/\____/_____/  /_/     /_/ /_/ /_/ /_/\____/_/ |_/   /____/_____/_/ |_|
  </pre>

  </div>

  BGE 开放平台 是一个跨越多级数据的（多）组学数据平台，开发者在获得用户授权后，将可以通过开放平台提供的 API 访问关联用户的（多）组学数据，甚至写入数据。

  基于开放平台 API，开发者可避免重复开发采样、提取、测序和生信分析等繁复的流程，直接使用清洁的结构化数据。

  开发者可以通过开放平台提供的 API 创建极具创意性的（多）组学应用，如：

  * 包含药物代谢或药物服用建议的应用
  * 包含体检数据和营养代谢基因的餐饮应用
  * 包含肠道菌群数据和痛风相关基因的痛风管理应用
  * 基于祖源成分的社交网络应用，等等

  BGE 开放平台 API 基于 OAuth 2.0 开发，并使用 SSL/TLS 加密传输，确保用户数据正确无误地授权，并安全地传输到第三方应用，确保用户数据不会被未经授权的应用获得。



  推荐使用 pip 进行安装。

  ```shell
  $ pip install -U bge-python-sdk
  ```

  或者

  ```shell
  $ make install
  ```

  再或者

  ```shell
  $ python setup.py install
  ```



  更加详细的 SDK 文档请查看 [SDK Documents](https://api.bge.genomics.cn/doc/#/sdk/README)。



  BGE 开放平台支持 OAuth2 的两种模式，分别是用户授权模式、客户端模式。

  详情请参考开放平台文档 [https://api.bge.genomics.cn/doc](https://api.bge.genomics.cn/doc) 。



  BGE 开放平台提供了如下可用的 `endpoint`。

  | endpoint                    | 解释                                                        |
  | --------------------------- | ----------------------------------------------------------- |
  | https://api.bge.genomics.cn | **线上环境** 主域名地址                                     |
  | https://api.bge.omgut.com   | **线上环境** 副域名地址，主域名地址不可用时可替换此域名地址 |



  ```python
  from bgesdk import OAuth2, API

  code = '???????'  # 用户确认授权后平台返回的授权码
  client_id = 'demo'
  client_secret = 'demo'
  redirect_uri = 'http://test.cn'
  oauth2 = OAuth2(
      client_id, client_secret,
      endpoint='https://api.bge.genomics.cn', max_retries=3, timeout=16,
      verbose=False)
  token = oauth2.exchange_authorization_code(code, redirect_uri)

  api = oauth2.get_api(token.access_token)
  print(api.get_user())

  api = API(token.access_token)
  print(api.get_user())
  ```



  ```python
  from bgesdk import OAuth2, API

  client_id = 'demo'
  client_secret = 'demo'
  oauth2 = OAuth2(
      client_id, client_secret,
      endpoint='https://api.bge.genomics.cn', max_retries=3, timeout=16,
      verbose=False)
  token = oauth2.get_credentials_token()

  api = oauth2.get_api(token.access_token)
  print(api.get_variants('E-B1243433', 'rs333'))

  api = API(token.access_token)
  print(api.get_variants('E-B1243433', 'rs333'))
  ```



  * xiangji1204's [github](https://github.com/xiangji1204)
  * leafcoder(leafcoder@gmail.com)'s [github](https://github.com/leafcoder)


pkgId: 2035638fa2760ba9375ebc26d8267200678318fb420bdd59e8b873dc427a0818
name: python-bgg-api
arch: src
version: 1.1.10
epoch: 0
release: 1
summary: A Python API for boardgamegeek.com
url: https://github.com/SukiCZ/boardgamegeek
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bgg-api-1.1.10-1.src.rpm
checksum_type: sha256
description:
  [![docs status](https://readthedocs.org/projects/bgg-api/badge/?version=latest)](https://bgg-api.readthedocs.io/en/latest/)
  [![ci workflow status](https://github.com/SukiCZ/boardgamegeek/actions/workflows/ci.yml/badge.svg)](https://github.com/SukiCZ/boardgamegeek/actions)
  [![codecov](https://codecov.io/gh/SukiCZ/boardgamegeek/graph/badge.svg?token=LMOWZ62OIS)](https://codecov.io/gh/SukiCZ/boardgamegeek)
  [![Black code style](https://img.shields.io/badge/code_style-black-000000.svg)](https://github.com/ambv/black)
  ![Contributions welcome](https://img.shields.io/badge/contributions-welcome-green.svg)



  ```bash
  pip install bgg-api
  ```



  ```python
  from boardgamegeek import BGGClient

  bgg = BGGClient()

  game = bgg.game("Monopoly")

  print(game.year)  # 1935
  print(game.rating_average)  # 4.36166
  ```



  ```bash

  pip install -r requirements/develop.txt

  pre-commit install


  pytest .

  tox
  ```



  ```bash

  bump2version patch

  git push --tags origin master
  ```


pkgId: 293f20f958ea61e628a021dfb60c29957fc53bfe7761f76fead9f7b9d876cdca
name: python-bgmi
arch: src
version: 4.5.0
epoch: 0
release: 1
summary: BGmi is a cli tool for subscribed bangumi.
url: https://github.com/BGmi/BGmi
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bgmi-4.5.0-1.src.rpm
checksum_type: sha256
description:
  BGmi 是一个用来追番的命令行程序.

  [![](https://img.shields.io/pypi/v/bgmi.svg)](https://pypi.python.org/pypi/bgmi)
  ![](https://img.shields.io/pypi/pyversions/bgmi)
  [![test](https://github.com/BGmi/BGmi/actions/workflows/test.yaml/badge.svg)](https://github.com/BGmi/BGmi/actions/workflows/test.yaml)
  [![](https://codecov.io/gh/BGmi/BGmi/branch/master/graph/badge.svg)](https://codecov.io/gh/BGmi/BGmi/branch/master/graph/badge.svg)
  [![](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/BGmi/BGmi/blob/master/LICENSE)







  - 命令自动补全，使用 `bgmi completion zsh/bash` 生成
  - 添加 `mikan_url` 配置，用于配置蜜柑计划镜像站。
  - 添加 `proxy` 设置
  - 新 WEB UI
  - 将配置项 `transmission.rpc_url` 重命名为 `transmission.rpc_host`.
  - 修复 Transmission 配置的默认值.



  - 新增配置项 `global_include_keywords` ，用于设置全局包含关键词。
  - 新增配置项 `save_path_map` ，用于设置不同动画的下载路径。
  - 使用 [TOML](https://github.com/toml-lang/toml) 作为配置文件
  - 不再支持 python3.7
  - 不再支持 python3.6
  - 支持[扩展下载方式](./docs/downloader.md)
  - 移除迅雷离线
  - 支持 [qbittorrent-webapi](https://www.qbittorrent.org/)
  - 停止支持 python2，3.4 和 3.5
  - Transmission rpc 认证设置
  - 支持 [deluge-rpc](https://www.deluge-torrent.org/)
  - 使用最大和最小集数筛选搜索结果



  - 多个数据源可选: [bangumi_moe](https://bangumi.moe), [mikan_project](https://mikanani.me) 或者[dmhy](https://share.dmhy.org/)
  - 使用 aria2, transmission, qbittorrent 或者 deluge 来下载你的番剧.
  - 提供一个管理和观看订阅番剧的前端.
  - 弹幕支持
  - 提供 uTorrent 支持的 RSS Feed 和移动设备支持的 ICS 格式日历.
  - Bangumi Script: 添加自己的番剧解析器
  - 番剧放松列表和剧集信息
  - 下载番剧时的过滤器(支持关键词,字幕组和正则)
  - 多平台支持: Windows, \*nux 以及 Router system

  ![](./images/bgmi_cli.png?raw=true)
  ![](https://github.com/BGmi/BGmi-frontend/raw/master/.github/images/example.png)
  ![](https://github.com/BGmi/BGmi-frontend/raw/master/.github/images/example2.png)



  使用 [pipx](https://pypa.github.io/pipx/) 安装(推荐):

  ```bash
  pipx install bgmi
  ```



  ```bash
  pip install bgmi
  ```



  ```bash
  git clone https://github.com/BGmi/BGmi
  cd BGmi
  git checkout master
  python -m pip install -U pip
  pip install .
  ```



  ```bash
  bgmi install
  ```



  ```bash
  pipx upgrade bgmi
  bgmi upgrade
  ```



  ```bash
  pip install bgmi -U
  bgmi upgrade
  ```

  在升级后请确保运行`bgmi upgrade`



  见 [BGmi/bgmi-docker-all-in-one](https://github.com/BGmi/bgmi-docker-all-in-one)



  查看可用的命令

  ```bash
  bgmi --help
  ```

  **`--help`选项同样适用于所有的子命令，readme 仅介绍了一些基础用法。**





  ```shell
  bgmi completion bash > ~/.bash_completion.d/bgmi
  ```




  ```shell
  bgmi completion zsh > .oh-my-zsh/completions/_bgmi
  ```

  我不使用其他的 zsh 插件管理器，具体的安装方法请查询你使用的插件管理器文档



  BGmi 提供两种方式配置BGmi的各项运行参数，分别为配置文件与环境变量。


  bgmi 的配置文件位于 `${BGMI_PATH}/config.toml`, 在未设置 `BGMI_PATH` 环境变量时，`${BGMI_PATH}` 默认为 `~/.bgmi/`。

  查看当前 `BGmi` 设置:

  ```bash
  bgmi config # 查看当前各项设置默认值.
  ```

  ```toml
  data_source = "bangumi_moe" # bangumi source，!!! 请不要手动修改此选项 !!!
  download_delegate = "aria2-rpc" # 番剧下载工具 (aria2-rpc, transmission-rpc, deluge-rpc, qbittorrent-webapi)
  tmp_path = "tmp/tmp" # tmp dir
  save_path = "tmp/bangumi" # 下载番剧保存地址
  max_path = 3 # 抓取数据时每个番剧最大抓取页数
  bangumi_moe_url = "https://bangumi.moe"
  share_dmhy_url = "https://share.dmhy.org"
  mikan_url = "https://mikanani.me"
  mikan_username = "" # 蜜柑计划的用户名
  mikan_password = "" # 蜜柑计划的密码
  enable_global_filters = true
  global_filters = [
      "Leopard-Raws",
      "hevc",
      "x265",
      "c-a Raws",
      "U3-Web",
  ]

  proxy = '' # http proxy example: http://127.0.0.1:1080

  [save_path_map] # 针对每部番剧设置下载路径
  '致不灭的你 第二季' = '/home/trim21/downloads/bangumi/致不灭的你/s2/' # 如果使用绝对路径，可能导致 web-ui 无法正确显示视频文件。
  '致不灭的你 第三季' = './致不灭的你/s3/' # 以 save_path 为基础路径的相对路径

  [http]
  admin_token = "dYMj-Z4bDRoQfd3x" # web ui 的密码
  danmaku_api_url = ""
  serve_static_files = false

  [aria2]
  rpc_url = "http://localhost:6800/rpc" # aria2c RPC URL (不是 jsonrpc URL, 如果你的 aria2c 运行在 localhost:6800, 对应的链接为 `http://localhost:6800/rpc`)
  rpc_token = "token:" # aria2c RPC token (如果没有设置 token, 留空或者设置为 `token:`)

  [transmission]
  rpc_host = "127.0.0.1"
  rpc_port = 9091
  rpc_username = "your_username"
  rpc_password = "your_password"
  rpc_path = "/transmission/rpc" # transmission http rpc 的请求路径

  [qbittorrent]
  rpc_host = "127.0.0.1"
  rpc_port = 8080
  rpc_username = "admin"
  rpc_password = "adminadmin"
  category = ""

  [deluge]
  rpc_url = "http://127.0.0.1:8112/json"
  rpc_password = "deluge"
  ```


  当 BGmi 的配置文件还未初始化时，各项运行参数可由环境变量进行配置

  环境变量以 `BGMI_` 开头，全大写命名，且各级配置以 `_` 进行分割，如:
  ```
  BGMI_DATA_SOURCE=bangumi_moe    # 对应配置文件中的 data_source = "bangumi_moe"
  BGMI_HTTP_ADMIN_TOKEN=dYMj-Z4bDRoQfd3x    # 对应配置文件 [http] 分段中的 admin_token = "dYMj-Z4bDRoQfd3x"
  ...
  ```

  环境变量 *暂不支持* 配置以下项目
  ```
  enable_global_include_keywords
  enable_global_filters
  global_include_keywords
  global_filters
  [save_path_map]
  ```
  注: 当配置文件生成完毕后，运行配置将会以配置文件为准，环境变量仅用于生成第一份配置文件。



  使用 `bgmi config set ...keys  --value '...'` 命令可以修改配置。

  如：

  ```shell
  bgmi config set http admin_token --value 'my super secret token'
  ```

  或者

  ```shell
  bgmi config set max_path --value '3'

  ```

  不能用来修改复杂配置，如 `global_filters`，请手动修改配置文件。



  - [bangumi_moe(default)](https://bangumi.moe)
  - [mikan_project](https://mikanani.me)
  - [dmhy](https://share.dmhy.org/)



  **更换数据源会清空番剧数据库, 但是 bgmi script 不受影响.** 之前下载的视频文件不会删除, 但是不会在前端显示

  **如果更换的源为 `mikan_project`, 请先配置 `MIKAN_USERNAME` 和 `MIKAN_PASSWORD`**, 其它源不受影响

  ```bash
  bgmi source mikan_project
  ```

  **切换数据源必需使用bgmi source命令，不能手动修改配置文件。手动修改配置文件会导致 bgmi 报错**



  修改配置文件和对应的配置项

  ```toml
  download_delegate = "aria2-rpc" # download delegate
  ```

  内置可用的选项包括 `aria2-rpc`, `transmission-rpc`, `qbittorrent-webapi` 以及 `deluge-rpc`。



  ```bash
  bgmi cal
  ```

  订阅番剧:

  ```bash
  bgmi add "进击的巨人 第三季" "刃牙" "哆啦A梦"
  bgmi add "高分少女" --episode 0
  ```

  添加番剧的同时设置下载路径:

  ```bash
  bgmi add "高分少女" --episode 0 --save-path './高分少女/S1/'
  ```

  退订:

  ```bash
  bgmi delete "Re:CREATORS"
  ```

  更新番剧列表并且下载番剧:

  ```bash
  bgmi update --download # update all
  bgmi update "从零开始的魔法书" --download
  ```

  设置筛选条件:

  ```bash
  bgmi list # 列出目前订阅的番剧
  bgmi fetch "Re:CREATORS"

  bgmi filter "Re:CREATORS" --subtitle "DHR動研字幕組,豌豆字幕组" --include 720P --exclude BIG5
  bgmi fetch "Re:CREATORS"

  bgmi filter "Re:CREATORS" --subtitle "" --include "" --exclude "" --regex "..."
  bgmi filter "Re:CREATORS" --regex "(DHR動研字幕組|豌豆字幕组).*(720P)"
  bgmi fetch "Re:CREATORS"
  ```






  默认不启用全局包含关键词，你可以设置 `enable_global_include_keywords = true` 启动此功能。

  ```toml
  enable_global_include_keywords = true
  global_include_keywords = ['1080']
  ```




  有一些默认定义的全局过滤关键词，默认会排除标题包含以下关键词的种子。
  可以使用 `enable_global_filters = false` 禁止过滤全局关键词，

  ```toml
  enable_global_filters = true
  global_filters = [
    "Leopard-Raws",
    "hevc",
    "x265",
    "c-a Raws",
    "U3-Web",
  ]
  ```

  最后使用`bgmi fetch`来看看筛选的结果.

  搜索番剧并下载:

  ```bash
  bgmi search '为美好的世界献上祝福！' --regex-filter '.*动漫国字幕组.*为美好的世界献上祝福！].*720P.*'

  ```

  使用`--min-episode`和`--max-episode`来根据集数筛选下载结果

  ```bash
  bgmi search 海贼王 --min-episode 800 --max-episode 820

  bgmi search 海贼王 --min-episode 800 --max-episode 820 --download
  ```

  `bgmi search`命令默认不会显示重复的集数, 如果要显示重复的集数来方便过滤, 在命令后加上`--dupe`来显示全部的搜索结果

  手动修改最近下载的剧集

  ```bash
  bgmi list
  bgmi mark "Re:CREATORS" 1
  ```



  1.先下载所有更新中番剧的封面

  ```bash
  bgmi cal --download-cover
  ```

  2.根据你是否使用 nginx, 设置`serve_static_files`(使用 nginx 的情况下使用默认设置`false`, 不使用的情况下设置为`true`)

  3.下载前端的静态文件(你可能在安装的时候已经下载过了):

  ```bash
  bgmi install
  ```

  4.在`8888`端口启动 BGmi HTTP 服务器:

  ```bash
  bgmi_http --port=8888 --address=0.0.0.0
  ```



  参照上面启动服务器, 然后访问[http://localhost:8888/](http://localhost:8888/).



  可以让`BGmi`帮助你生成对应的 nginx 配置文件

  ```bash
  bgmi gen nginx.conf --server-name bgmi.whatever.com
  ```

  你也可以手动写一份 nginx 配置, 来满足你的更多需求(比如启用 https), 这是一份例子

  ```bash
  server {
      listen 80;
      server_name bgmi;

      autoindex on;
      charset utf-8;

      location /bangumi {
          
          
          alias /path/to/bangumi/;
      }

      location /api {
          proxy_pass http://127.0.0.1:8888;
      }

      location /resource {
          proxy_pass http://127.0.0.1:8888;
      }

      location / {
          
          alias /path/to/front_static/;
      }
  }
  ```

  或者添加一个 aria2c 前端之类的, 具体办法百度上有很多,不在此赘述.

  macOS launchctl service controller

  参照 [issue #77](https://github.com/BGmi/BGmi/pull/77)自行设置

  [me.ricterz.bgmi.plist](https://github.com/BGmi/BGmi/blob/master/bgmi/others/me.ricterz.bgmi.plist)



  BGmi 使用[`DPlayer`](https://github.com/DIYgod/DPlayer)做为前端播放器

  如果你想要添加弹幕支持, 在这里[DPlayer#related-projects](https://github.com/DIYgod/DPlayer#related-projects)选择一个后端自行搭建, 或者使用`DPlayer`提供的现成接口`https://api.prprpr.me/dplayer/`

  然后修改配置文件：

  ```toml
  [bgmi_http]
  danmaku_api_url = "https://api.prprpr.me/dplayer/"  # This api is provided by dplayer official
  ```

  设置你的`bgmi_http`, 享受弹幕支援吧.



  log 文件位于`{BGMI_PATH}/tmp/`



  由于 pip 的限制, 你需要手动清理`BGmi`产生的位于`~/.bgmi`的文件

  同样, `BMmi`添加到你系统的定时任务也不会被自动删除, 请手动删除.

  \*nix:

      请手动清理crontab

  windows:

  ```bash
  schtasks /Delete /TN 'bgmi updater'
  ```





  你可以写一个`BGmi Script`来解析你自己的想看的番剧或者美剧. BGmi 会加载你的 script, 视作一个番剧来对待. 而你所需要做的只是继承`ScriptBase`类, 然后实现特定的方法, 再把你的 script 文件放到`BGMI_PATH/script`文件夹内.

  Example: [./tests/script_example.py](./tests/script_example.py)

  `get_download_url()`返回一个`dict`, 以对应集数为键, 对应的下载链接为值

  ```python
  {
      1: 'http://example.com/Bangumi/1/1.mp4',
      2: 'http://example.com/Bangumi/1/2.torrent',
      3: 'http://example.com/Bangumi/1/3.mp4'
  }
  ```



  你可以在下载完成前或下载完成后执行一些操作, 比如移动文件, 重命名文件等等. 将你的 hook 文件放到`BGMI_PATH/hooks`文件夹内即可.

  ```python
  from loguru import logger
  from bgmi.script import HookBase



  class Hook(HookBase):
      
      def post_add_download(self) -> None:
          logger.info('post add download')

      
      def pre_add_download(self) -> None:
          logger.info('pre add download')
  ```



  通过扩展`bgmi.website.base.BaseWebsite`类并且实现对应的三个方法,你也可以简单的添加一个数据源

  每个方法具体的意义和返回值格式请参照每个方法对应的注释

  ```python
  from typing import List, Optional

  from bgmi.website.base import BaseWebsite
  from bgmi.website.model import Episode, WebsiteBangumi


  class DataSource(BaseWebsite):
      def search_by_keyword(
          self, keyword: str, count: int
      ) -> List[Episode]:  # pragma: no cover
          """

          :param keyword: search key word
          :param count: how many page to fetch from website
          :return: list of episode search result
          """
          raise NotImplementedError

      def fetch_bangumi_calendar(self,) -> List[WebsiteBangumi]:  # pragma: no cover
          """
          return a list of all bangumi and a list of all subtitle group

          list of bangumi dict:
          update time should be one of ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Unknown']
          """
          raise NotImplementedError

      def fetch_episode_of_bangumi(
          self, bangumi_id: str, max_page: int, subtitle_list: Optional[List[str]] = None
      ) -> List[Episode]:  # pragma: no cover
          """
          get all episode by bangumi id

          :param bangumi_id: bangumi_id
          :param subtitle_list: list of subtitle group
          :type subtitle_list: list
          :param max_page: how many page you want to crawl if there is no subtitle list
          :type max_page: int
          :return: list of bangumi
          """
          raise NotImplementedError


      def fetch_single_bangumi(self, bangumi_id: str) -> WebsiteBangumi:
          """
          fetch bangumi info when updating

          :param bangumi_id: bangumi_id, or bangumi['keyword']
          :type bangumi_id: str
          :rtype: WebsiteBangumi
          """
          
  ```



  [MIT License](./LICENSE)


pkgId: a75c03484bb9398324d7a0d8025cc1e65144b4c8915c23645c7367716eb13c66
name: python-bgmiget
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: a way to download anime.
url: https://pypi.org/project/bgmiget/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bgmiget-1.0.5-1.src.rpm
checksum_type: sha256
description:
  BgmiGet is a command line tool that allows you to search, download, and manage your favorite anime. It provides a simple and efficient way to keep track of the latest episodes and download them with ease.



  > [!NOTE]
  > PyPdf requires Python 3.8.1.



  To install BgmiGet, you can use pip:
  ```
  pip install bgmiget
  ```





  To search for anime, use the "search" command. The format is as follows:
  ```
  bgmiget search <anime_name> <episode_number> "<source>" "<subtitle_group>"
  ```
  For example:
  ```
  bgmiget search "因为太怕痛" 7 "sc" "桜都字幕组"
  ```
  This will search for the anime "因为太怕痛" with episode number 7 from source "sc" and subtitle group "桜都字幕组". The result will be displayed as:
  ```
  >0  -> 【因为太怕痛...】【07】【桜都字幕组】
  ```



  Once you have found the anime you want, you can download it by its index. For example, to download the anime with index 0:
  ```
  bgmiget download 0
  ```



  To subscribe to an anime, use the "subscribe" command. To list all subscribed anime, use the "show_subscribed" command.



  To check for updates on subscribed anime, use the "upgrade" command. This will ensure you always have the latest episodes of your subscribed anime.


pkgId: 4642b6e35abc978385fa49559eb0663852b36ef9553d27a0c69c533f01536a4b
name: python-bgpneiget
arch: src
version: 2.0.16
epoch: 0
release: 1
summary: Get BGP Neighbours from network devices
url: https://github.com/robwdwd/bgpneiget
rpm_license: BSD-2-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bgpneiget-2.0.16-1.src.rpm
checksum_type: sha256
description:
  Get BGP neighbours from network devices and output a json
  object.



  Create a config file in ~/.config/bgpneiget/config.json

  ```json
  {
      "username": "user",
      "password": "password"
  }
  ```



  Run the command with --help to see command line options.


pkgId: 165474672063c1ec034cfb4e1d08b78807c9d801bb399396ed1d2d9f14f97946
name: python-bgpy-pkg
arch: src
version: 11.3.3
epoch: 0
release: 1
summary: Simulates BGP, ROV, ASPA, etc in an extensible manner
url: https://github.com/jfuruness/bgpy_pkg
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bgpy-pkg-11.3.3-1.src.rpm
checksum_type: sha256
description:
  Docs [here](https://github.com/jfuruness/bgpy/wiki)



  ```
  @inproceedings{10.1145/3607505.3607509,
  author = {Furuness, Justin and Morris, Cameron and Morillo, Reynaldo and Herzberg, Amir and Wang, Bing},
  title = {BGPy: The BGP Python Security Simulator},
  year = {2023},
  isbn = {9798400707889},
  publisher = {Association for Computing Machinery},
  address = {New York, NY, USA},
  url = {https://doi.org/10.1145/3607505.3607509},
  doi = {10.1145/3607505.3607509},
  abstract = {The security of Border Gateway Protocol (BGP), and inter-domain routing in general, remains a challenge, in spite of its well-known importance, repeated attacks and incidents, and extensive efforts and research over decades. We present BGPy, an open-source, extensible, robust, easy-to-use and efficient BGP security simulator, to be used for research and education. BGPy allows realistic simulations of a large variety of BGP attacks and defenses. It is provided as a Python package, and can be further customized and extended, e.g., to investigate new attacks and new defense mechanisms. We describe how BGPy is currently used by multiple BGP security projects.},
  booktitle = {Proceedings of the 16th Cyber Security Experimentation and Test Workshop},
  pages = {41–56},
  numpages = {16},
  location = {Marina del Rey, CA, USA},
  series = {CSET '23}
  }
  ```

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


pkgId: e4512c3af053fe1827e20ab6e7281a739c933ee06da011267e6ff8cd6f5c60c5
name: python-bgpy-pkg
arch: src
version: 12.0.2
epoch: 0
release: 1
summary: Simulates BGP, ROV, ASPA, etc in an extensible manner
url: https://github.com/jfuruness/bgpy_pkg
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bgpy-pkg-12.0.2-1.src.rpm
checksum_type: sha256
description:
  ![PyPI Downloads](https://static.pepy.tech/badge/bgpy-pkg)
  [![PyPI version](https://badge.fury.io/py/bgpy_pkg.svg)](https://badge.fury.io/py/bgpy_pkg)
  ![PyPy](https://img.shields.io/badge/PyPy-7.3.17-blue)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/bgpy_pkg)](https://pypi.org/project/bgpy_pkg/)
  ![Tests](https://github.com/jfuruness/bgpy/actions/workflows/tests.yml/badge.svg)
  ![Linux](https://img.shields.io/badge/os-Linux-blue.svg)
  ![macOS Intel](https://img.shields.io/badge/os-macOS_Intel-lightgrey.svg)
  ![macOS ARM](https://img.shields.io/badge/os-macOS_ARM-lightgrey.svg)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Checked with mypy](https://img.shields.io/badge/mypy-checked-2A6DBA.svg)](http://mypy-lang.org/)
  [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
  [![Pylint](https://img.shields.io/badge/linting-pylint-yellowgreen)](https://github.com/pylint-dev/pylint/tree/main)
  [![try/except style: tryceratops](https://img.shields.io/badge/try%2Fexcept%20style-tryceratops%20%F0%9F%A6%96%E2%9C%A8-black)](https://github.com/guilatrova/tryceratops)



  Welcome to BGPy! One of the worlds leading Python BGP security simulators. You're in good company; this simulator has been used by teams all around the world, including NIST. BGPy is also [peer-reviewed research](https://dl.acm.org/doi/fullHtml/10.1145/3607505.3607509) and has been featured in [several publications](https://github.com/jfuruness/bgpy/wiki/Citations-and-Use-Cases), with many more ongoing.

  With BGPy, you can simulate the entire internet topology on your laptop. You can program your own security policies & attacks, use the topology for custom analysis, use real-world ROV data, etc. BGPy also comes with a custom test suite that allows for easy testing of security protocols. We support [more than 20 policies](https://github.com/jfuruness/bgpy_pkg/wiki/Routing-Policies) including ROV, ASPA,  and ASRA.

  If you're looking for an in depth tutorial as to the features, and how to use BGPy, I highly recommend the [tutorial](https://github.com/jfuruness/bgpy/wiki/Tutorial).

  If you're just looking to run/visualize attack/defense scenarios without programming, I recommend checking out the front-end for this tool: [BGPSimulator.com](https://www.bgpsimulator.com)

  If you're looking to cite BGPy or check out the use cases, you can find that [here](https://github.com/jfuruness/bgpy/wiki/Citations-and-Use-Cases). If you end up citing BGPy please let us know and we'll add you to the list :)



  * [Tutorial](https://github.com/jfuruness/bgpy/wiki/Tutorial)
  * [Citations and Use Cases](https://github.com/jfuruness/bgpy/wiki/Citations-and-Use-Cases)
  * [Installation](https://github.com/jfuruness/bgpy/wiki/Installation)
  * [Testing](https://github.com/jfuruness/bgpy/wiki/Testing)
  * [Development/Contributing](https://github.com/jfuruness/bgpy/wiki/Development-Contributing)
  * [History](https://github.com/jfuruness/bgpy/wiki/History)
  * [Credits](https://github.com/jfuruness/bgpy/wiki/Credits)
  * [License](https://github.com/jfuruness/bgpy/blob/master/LICENSE)
  * [FAQ](https://github.com/jfuruness/bgpy/wiki/FAQ)

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


pkgId: 2964b2c1199717acef5cd0b88ed7dfbdc8d6f59a269a6d40dce019225c66b771
name: python-bgtasks
arch: src
version: 0.0.44
epoch: 0
release: 1
summary: Microservice with django
url: https://github.com/myrubapa/bgtasks
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bgtasks-0.0.44-1.src.rpm
checksum_type: sha256
description:
  bgtasks is python library for dealing with data exchange between
  micro services using rabbitmq protocol. Moreover, you can use it as trigger for events which belongs to another services.


  Use the package manager [pip](https://pip.pypa.io/en/stable/) to install bgtasks.
  ```shell
  pip install bgtasks
  ```





  ```python
  AMQP = {
      'USERNAME': 'guest',
      'PASSWORD': 'guest',
      'VHOST': '/',
      'HOST': 'localhost',
      'PORT': 5672,
      'RPC_SLEEP_TIME': 0.005,
      'RPC_TIMEOUT': 5,
  }
  ```

  ```
  'RPC_TIMEOUT': 60
  'RPC_SLEEP_TIME': 0.05,
  ```





  ```python
  from bgtasks import rpc_tasks
  from bgtasks import Response

  @rpc_tasks('message')
  def handle(data):
      print(data)
      return Response('I received your message %s' % data)
  ```
  To get response
  ```python
  from bgtasks import RPCClient

  rpc_client = RPCClient()

  try:
      response = rpc_client.call('message', 'Hi')
      print(response)
  except TimeoutError:
      print('Service is not responding')
  ```
  In order to avoid conflicts between remote procedure calls you should pass parameters **explicitly with keywords**

  To run rpc task run command below
  ```bash
  python manage.py tasks
  ```



  models.py
  ```python
  from django.db import models

  class Category(models.Model):
      name = models.CharField(max_length=255)
  ```
  In this case your `add` should receive arguments' list with explicit variable name `ids`

  tasks.py
  ```python
  from bgtasks import rpc_tasks
  from bgtasks import Response
  from bgtasks import serializer_class
  from testapp.models import Category
  from rest_framework import serializers


  class CategorySerializer(serializers.ModelSerializer):
      class Meta:
          model = Category
          fields = ('id', 'name')


  @rpc_tasks('add')
  @serializer_class(CategorySerializer, many=True)
  def handle(serializer):
      serializer.save()
      return Response(serializer.data)


  @rpc_tasks('get')
  @serializer_class()
  def handle(serializer):
      queryset = Category.objects.filter(id__in=serializer.validated_data['ids'])
      serializer = CategorySerializer(queryset, many=True)
      return Response(serializer.data)
  ```


  ```python
  from django.db import models
  from bgtasks.models import RemoteField

  class Product(models.Model):
      name = models.CharField(max_length=255)
      category = RemoteField() # in our case, it is in another service id

  ```


  ```python
  from rest_framework import serializers
  from bgtasks.rest_framework.fields import RemoteField
  from app1.models import Product


  class ProductSerializer(serializers.ModelSerializer):
      category = RemoteField(route='get')

      class Meta:
          model = Product
          fields = ('id', 'name', 'category', )
  ```

  And make sure that returned response should be formed as below format.
  ```python
  {
      'status': 'success/fail',
      'data': [
          {
              'id': 1,
              
          },
          {
              'id': 2,
              
          }
      ]
  }
  ```


  In order to avoid from sending many rpc requests at first level of serializer we added RPCSerializerMixin
  ```python
  from bgtasks import RemoteField
  from bgtasks.rest_framework.serilaizers import RPCSerializerMixin
  from rest_framework import serializers
  from app1.models import Product

  class ProductListSerializer(RPCSerializerMixin, serializers.ModelSerializer):
      category = RemoteField(route='get')

      class Meta:
          model = Product
          fields = '__all__'

  users = Product.objects.all()
  serializer = ProductListSerializer(users, many=True)
  print(serializer.data)
  ```
  It will send to `route` **one** request with gathered pks in body as `[1,2,3,4,5]`, after which will be iterated to merge current serializer data
  which maps to `id` field in rpc response

  ```python
  [
      {
          'id': 1,
          'name': 'IPhone',
          'category': {
              'id': 5,
              'name': 'Phone',
          }
      },
      {
          'id': 2,
          'name': 'LG Smart Tv',
          'category': {
              'id': 3,
              'name': 'TV',
          }
      },
  ]
  ```


  To handle `many=True` in serializer we introduce `RPCSerializerMixin` which uses merge functions.
  You can import them as below, and to understand can look to function profile.
  ```python
  from bgtasks.utils.merge import merge, merge_dict, merge_obj
  ```


  Add `ENVIRONMENT = 'test'` on settings.py in order to imitate response from
  another service
  ```python
  import json
  from django.test import TestCase
  from django.test import Client
  from bgtasks import rpc_tasks
  from bgtasks import RPCClient
  from bgtasks import SUCCESS
  from bgtasks.amqp import register_tasks


  @rpc_tasks('user.add')
  def add_user(data):
      return 1

  class RPCTestCase(TestCase):
      def setUp(self):
          register_tasks() # If you want to run your tasks to test them out, not only rpc tasks which are registered inside of your test file

      def test_add_user(self):
          data = {'username': 'john', 'password': 'smith'}
          c = Client()
          response = c.post('/user/add/', data)
          data = json.loads(response.content)
          self.assertEqual(response.status_code, 201)
          self.assertEqual(data['user_id'], 1)


      def test_your_tasks(self):
          data = RPCClient().call('mytasks', {})
          self.assertEqual(data['status'], SUCCESS)

  ```



  Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

  Please make sure to update tests as appropriate.


  Create config file in home directory `~/.pypirc`
  ```
  [distutils]
  index-servers=pypi
  [pypi]
  repository = https://upload.pypi.org/legacy/
  username = myrubapa
  ```
  After run command for build and deploy
  ```shell
  python3 setup.py sdist bdist_wheel
  python3 -m twine upload dist/*
  ```

  for more detail read [packaging-projects](https://packaging.python.org/tutorials/packaging-projects/)

  [MIT](https://choosealicense.com/licenses/mit/)


pkgId: 5a01b570e337d2f5276be260363212b08a38dd91e8ff8371de8cc12ba54ce4c9
name: python-bgtunnel
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Initiate SSH tunnels in the background
url: https://github.com/jmagnusson/bgtunnel
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bgtunnel-0.4.1-1.src.rpm
checksum_type: sha256
description:
  * Bind address and host address defaults to "127.0.0.1"
  * SSH port defaults to 22
  * Bind port defaults to picking a random available one, accessible from the
    object returned by the `open` function


pkgId: 52d8943d1c3429d46acda95e0c2fc1cdbc62aaed7d03c9229e0b20ddf097b9d1
name: python-bgutil-ytdlp-pot-provider
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/bgutil-ytdlp-pot-provider/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bgutil-ytdlp-pot-provider-0.6.1-1.src.rpm
checksum_type: sha256
description:
  If using option (b) script for the provider, with the default script location in your home directory (i.e: `~/bgutil-ytdlp-pot-provider`), you can also use yt-dlp like normal.
  If you installed the script in a different location, pass it as the extractor argument `getpot_bgutil_script` to `youtube` for each yt-dlp call.
  ```shell
  --extractor-args "youtube:getpot_bgutil_script=$WORKSPACE/bgutil-ytdlp-pot-provider/server/build/generate_once.js"


pkgId: 416927f66927a66483062ef4b3b30aba248802bcd43cf18fbd39c292f07c08a4
name: python-bhfutils
arch: src
version: 0.1.18
epoch: 0
release: 1
summary: Utilities that are used by any spider of Behoof project
url: https://behoof.app/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bhfutils-0.1.18-1.src.rpm
checksum_type: sha256
description:
  The ``bhfutils`` package is a collection of utilities that are used by any spider of Behoof project.


pkgId: 93aba0a85c2e429037f6ebc00bed8d61756e8f327b8559861f9a059d7a693c90
name: python-bhmsh
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: A lightweight OpenAI-powered Bash actuator.
url: https://github.com/Business-Handyman-LLC/bhm-sh
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bhmsh-1.1.3-1.src.rpm
checksum_type: sha256
description:
  A lightweight OpenAI-powered Bash actuator.



  ```
  python3 -m pip install --upgrade bhmsh
  ```

  BHMsh requires Python 3.8 or greater and a Unix-based OS (macOS or Linux).

  **_With that being said, there are currently build issues with the latest Python 3.12: use 3.8 - 3.11._**



  Download an acceptable version of Python 3 [here](https://www.python.org/downloads/).

  To verify:

  ```
  python3 --version
  ```

  If you don't see the correct version after running this, you may need to consult the interent on Python installation locations for your specific OS.
  And then you'll need to update your `PATH` environment variable accordingly.

  Once you have an acceptable version of Python 3, doing the following doesn't hurt:

  ```
  python3 -m pip install --upgrade pip setuptools wheel
  ```



  Most basic execution explicitly using your OpenAI API key:

  ```
  bhmsh -t <your-openai-api-key>
  ```

  You can also execute BHMsh in the following manner:

  ```
  bhmsh
  ```

  This will check your current environment for an exported variable `OPENAI_API_KEY` containing your OpenAI API key.

  If you want to see a log of BHMsh's interation with GPTsh:

  ```
  bhmsh --log
  ```

  This will create a tail-able log file (`tail -f <path-to-log>` in a concurrent terminal).
  Its path is given upon execution.

  For full execution parameter details:

  ```
  bhmsh --help
  ```



  | Command        | Description                  |
  |:-------------- |:---------------------------- |
  | (c)lear        | Starts a new ChatGPT session |
  | (q)uit, (e)xit | Quit BHMsh                   |


pkgId: 6c621ba83e8c67ff02e92c574e2d13093db038cf74a39b5a6f2195ac0b2bcef0
name: python-bhoonidhi-downloader
arch: src
version: 0.1.21
epoch: 0
release: 1
summary: Command line tool for searching and downloading satellite data from Bhoonidhi
url: https://pypi.org/project/bhoonidhi-downloader/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bhoonidhi-downloader-0.1.21-1.src.rpm
checksum_type: sha256
description:
  A Python CLI tool for searching and downloading satellite imagery from Bhoonidhi Browse & Order Portal.



  ```shell
  pip install bhoonidhi-downloader
  ```



  Basic usage:

  **Authenticate**:

  ```shell
  bhoonidhi-downloader authenticate <username> --password <password>
  ```

  **Search Scenes using Bounding Box Coordinates**:

  ```shell
  bhoonidhi-downloader search <minx> <maxx> <miny> <maxy> <start_date> <end_date> <satellite> <sensor>
  ```

  Example - downloading a Sentinel-2A MSI scene from from December 2023 for Shillong, Meghalaya:

  ```shell
  bhoonidhi-downloader search 91.77 92 25.496 25.695 2023-12-01 2023-12-30 Sentinel-2A MSI
  ```

  For more information, use the `--help` option:

  **Display Bhoonidhi Browse & Order Archive**:

  ```shell
  bhoonidhi-downloader archive
  ```

  The `archive` command displays a table that listing all available satellites and their corresponding sensors along with information about availability, spatial resolution, and access level. The information can be filtered by satellite and sensor using the `--sat` options.

  Example - Displaying all available sensors and their information for ResourceSat-2 satellite:

  ```shell
  bhoonidhi-downloader archive --sat ResourceSat-2
  ```



  - Search for openly available satellite scenes from Bhoonidhi portal based on bounding box coordinates, date range, and satellite/sensor
  - View search results in tabular format with metadata and quicklook images
  - Download recent scenes that are available via direct download

  ![alt text](docs/image.png)



  - Supports only bounding box-based search for scenes.
    - Future support for search based on point coordinates and shapefile is planned.
  - Supports only scenes with direct download links
  - Supports only Low and Medium resolution scenes from Optical and Microwave Satellite Sensors.
    - Planning to add support for other sensors in future.
  - Direct downloads only work for images from recent past - upto a year or so depending on the area and sensor. To download scenes dated ealier than that, using the [Bhoonidhi Portal](https://bhoonidhi.nrsc.gov.in/bhoonidhi/index.html#) is recommended.
    - Planning to add support for interacting with carts by way of viewing, adding, deleting items in future. This will help with downloading older scenes.


pkgId: cadf3766026ebd81ed9f43e1613a7602bbae7c28c0ea41619d862df07bfd66cd
name: python-bhpy
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: Python bindings to use Becker & Hickls' hardware control dll and API
url: https://www.becker-hickl.com/products/bhpy
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bhpy-3.1.0-1.src.rpm
checksum_type: sha256
description:
  Python API for Becker&Hickl software products, data acquisition and data handling

  To install this module on your system, you can use pip:

      pip install bhpy

  or

      python3 -m pip install bhpy

  To access bhpy and its components import it into your Python code like this:

      import bhpy as bh



  [SPCConnect](https://www.becker-hickl.com/products/spcconnect) is a command based TCP interface for [SPCM](https://www.becker-hickl.com/products/spcm-data-acquisition-software) that allows programmatic access to SPCM's user interface. It can be used to automate measurements, create measurement feedback loops, integrate SPCM's functionality into your software or add other functionality to SPCM. Many parameters can be accessed through the interface directly, others can be set through predefined setups and will be added over time (requests can be submitted via the [bug tracker](https://github.com/bhmarscheck/bhpy/issues)). SPCConnect can also facilitate automated data analysis through SPCM as well as GPU accelerated fluorescence decay analysis with [SPCImage](https://www.becker-hickl.com/products/spcimage) by fitting the data with single-, double- and triple exponential decay models.



  Remote control interface for Becker&Hickl's LabView software products. Command based interface that allows programmatic access to their user interfaces, similar to SPCConnect. Currently supported LabView applications (requests can be submitted via the [bug tracker](https://github.com/bhmarscheck/bhpy/issues)):
  - BH-QC008



  Python wrapper for Becker&Hickl hardware control.



  BH device scanning dll wrapper that provides Python bindings to scan the system for all present Becker&Hickl devices, their serial number and firmware version.



  Dll wrapper for hardware configuration and data acquisition compatible with:
  - [SPC-QC-104](https://www.becker-hickl.com/products/spc-qc-104)/[004](https://www.becker-hickl.com/products/spc-qc-004)
  - [SPC-QC-108](https://www.becker-hickl.com/products/spc-qc-108-tcspc-module)/[008](https://www.becker-hickl.com/products/spc-qc-008-tcspc-module)
  - [PMS-800](https://www.becker-hickl.com/products/pms-800)


pkgId: 67ff65a27fbb72f335aa0cedb4299297efa5a9daf8b4251874c4d8a6b1c74a54
name: python-bi_etl
arch: src
version: 1.8.0
epoch: 0
release: 1
summary: Python ETL Framework
url: https://github.com/arcann/bi_etl
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bi_etl-1.8.0-1.src.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/bi-etl.svg)](https://pypi.org/project/bi-etl/)
  [![license](https://img.shields.io/github/license/arcann/config_wrangler.svg)](https://github.com/arcann/config_wrangler/blob/master/LICENSE)
  [![Python package](https://github.com/arcann/bi_etl/actions/workflows/unit_test.yml/badge.svg)](https://github.com/arcann/bi_etl/actions/workflows/unit_test.yml)



  [Please see the documentation site for detailed documentation.](https://bietl.dev/bi_etl/)

  Python based ETL (Extract Transform Load) framework geared towards BI databases in particular.
  The goal of the project is to create reusable objects with typical technical transformations used in loading dimension tables.


  1. Don’t Repeat Yourself (DRY).

  1. The source or target of an ETL owns the metadata (list of columns and data types). The ETL generally has no reason to define those again unless the ETL requires a change. If a datatype must be changed, only that one column’s new type should be specified. If a column name must be changed, only the source & target column names that differ should be specified.

  1. Data Quality is King

  1. Data quality is more important than performance. For example, the process should fail before truncating data contents (i.e. loading 6 characters into a 5 character field) even if that means sacrificing some load performance.

  1. Give helpful error messages.

  1. Make it as easy as possible to create re-usable modules.

  1. SQL is a very powerful transformation language. The Transform Extract Load (TEL) model should be supported.


pkgId: 96b9e85c23a41ae843cb503ba8c5187d4658599bb2724abcb6ae5e5475ad733b
name: python-bia-bob
arch: src
version: 0.23.3
epoch: 0
release: 1
summary: A Jupyter-based assistant for data analysis tasks
url: https://github.com/haesleinhuepf/bia-bob
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bia-bob-0.23.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/bia-bob.svg?color=green)](https://pypi.org/project/bia-bob)
  [![Contributors](https://img.shields.io/github/contributors-anon/haesleinhuepf/bia-bob)](https://github.com/haesleinhuepf/bia-bob/graphs/contributors)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/bia-bob)](https://pypistats.org/packages/bia-bob)
  [![GitHub stars](https://img.shields.io/github/stars/haesleinhuepf/bia-bob?style=social)](https://github.com/haesleinhuepf/bia-bob/)
  [![GitHub forks](https://img.shields.io/github/forks/haesleinhuepf/bia-bob?style=social)](https://github.com/haesleinhuepf/bia-bob/)
  [![License](https://img.shields.io/pypi/l/bia-bob.svg?color=green)](https://github.com/haesleinhuepf/bia-bob/raw/main/LICENSE)

  BIA `bob` is a Jupyter-based assistant for interacting with data using large language models which generate Python code for Bio-Image Analysis (BIA).
  It can make use of [OpenAI's chatGPT](https://openai.com/blog/openai-api), [Google's Gemini](https://blog.google/technology/ai/google-gemini-ai/), [Anthropic's Claude](https://www.anthropic.com/api), [Github Models Marketplace](https://github.com/marketplace/models), [Helmholtz' blablador](https://helmholtz-blablador.fz-juelich.de/) and [Ollama](https://ollama.com).
  You need an OpenAI API account or a Google Cloud account or a Helmholtz ID account to use it.
  Using it with Ollama is free but requires running an Ollama server locally.

  `bob` can write short Python code snippets and entire Jupyter notebooks for your image / data analysis workflow.

  ![img.png](https://github.com/haesleinhuepf/bia-bob/raw/main/docs/images/banner.png)



  `bia-bob` is a research project aiming at streamlining the design of image analysis workflows. Under the hood it uses
  artificial intelligence / large language models to generate text and code fulfilling the user's requests.
  Users are responsible to verify the generated code according to good scientific practice. Some general advice:
  * If you do not understand what a generated code snippet does, ask `%bob explain this code in detail to a Python beginner:` before executing the code.
  * After Bob generated a data analysis workflow for you, ask `%bob How could I verify this analysis workflow ?`. It is good scientific practice to measure the quality of segmentation results for example, or to measure the difference of automated quantitative measurements, in comparison to manual analysis.
  * If you are not sure if an image analysis workflow is valid, consider asking human experts. E.g. reach out via https://image.sc .

  > [!CAUTION]
  > When using the OpenAI, Google Gemini, Anthropic, Github Models or any other endpoint via BiA-Bob, you are bound to the terms of service
  > of the respective companies or organizations.
  > The prompts you enter are transferred to their servers and may be processed and stored there.
  > Make sure to not submit any sensitive, confidential or personal data. Also using these services may cost money.



  You can initialize `bob` like this:
  ```
  from bia_bob import bob
  ```



  You can ask Bob to generate code like this:
  ```
  %bob Load blobs.tif and show it
  ```

  It will then respond with a Python code snippet that you can execute ([see full example](https://github.com/haesleinhuepf/bia-bob/blob/main/demo/analysis_workflow.ipynb)):

  ![img.png](https://github.com/haesleinhuepf/bia-bob/raw/main/docs/images/load_and_show_blobs.png)

  Use `%bob` if you want to write in the same line and `%bob` if you want to write below.

  If you want to continue using a variable in the next code cell, you need to specify the name of the variable in the following prompt.



  When asking Bob explicitly to generate a notebook, it will put a new notebook file in the current directory with the generated code ([See full example](https://github.com/haesleinhuepf/bia-bob/blob/main/demo/generate_notebooks.ipynb)). You can then open it in Jupyter lab.

  ![img.png](https://github.com/haesleinhuepf/bia-bob/raw/main/docs/images/generate_notebook.gif)




  You can also ask Bob to modify an existing notebook, e.g. to introduce explanatory markdown cells ([See full example](https://github.com/haesleinhuepf/bia-bob/blob/main/demo/modifying_notebooks/modifying_notebooks.ipynb)):

  ![img.png](https://github.com/haesleinhuepf/bia-bob/raw/main/docs/images/modify_notebook.png)

  Furthermore, one can translate Jupyter notebooks to other languages, e.g. by prompting `%bob translate the filename.ipynb to <language>`.

  ![img.png](https://github.com/haesleinhuepf/bia-bob/raw/main/docs/images/translate.png)



  You can also ask Bob to write a prompt for you. This can be useful to explore potential strategies for analyzing image data.
  Note: It might be necessary to modify those prompts, especially when suggested analysis workflows are long and complicated.
  Shorten suggested prompts to the minimal necessary steps to answer your scientific question. ([See full example](https://github.com/haesleinhuepf/bia-bob/blob/main/demo/modifying_notebooks/writing_prompts.ipynb)).

  ![img.png](https://github.com/haesleinhuepf/bia-bob/raw/main/docs/images/writing_prompts.png)



  You can add additional information from given Python variables into your prompt using the `{variable_name}` syntax.
  With this, the content of the variable will become part of the prompt ([full example](https://github.com/haesleinhuepf/bia-bob/blob/main/demo/modifying_notebooks/augmenting_prompts.ipynb)).

  ![](https://github.com/haesleinhuepf/bia-bob/raw/main/docs/images/augmenting_prompts.png)



  If you are not sure what generated code does, you can ask Bob to explain it to you:

  ![](https://github.com/haesleinhuepf/bia-bob/raw/main/docs/images/explain_code.png)



  Bob can fix simple bugs in code you executed. Just add `%fix` on top of the cell right after the error happened.

  ![img.png](https://github.com/haesleinhuepf/bia-bob/raw/main/docs/images/bug_fixing_mini.gif)



  Using the `%doc` magic, you can generate documentation for a given code cell.

  ![img.png](https://github.com/haesleinhuepf/bia-bob/raw/main/docs/images/documenting_mini.gif)



  Using the `%acc` magic, you can replace common image processing functions with GPU-accelerated functions. It is recommended to check if the image processing results remain the same. You can see an example in [this notebook](https://github.com/haesleinhuepf/bia-bob/blob/main/demo/accelerate.ipynb).

  ![img.png](https://github.com/haesleinhuepf/bia-bob/raw/main/docs/images/accelerate.png)



  * [Examples](https://github.com/haesleinhuepf/bia-bob/tree/main/demo)



  You can use `bia-bob` from the terminal. This is recommended for creating notebooks for example like this:
  ```
  bia-bob Please create a Jupyter Notebook that opens blobs.tif, segments the bright objects and shows the resulting label image on top of the original image with a curtain.
  ```

  ![img_1.png](https://github.com/haesleinhuepf/bia-bob/raw/main/docs/images/cli_create_notebooks.png)

  This can also be used to create other files, e.g. CSV files.

  ![img.png](https://github.com/haesleinhuepf/bia-bob/raw/main/docs/images/cli_csv_files.png)




  If you want to ask `bob` a question, you need to put a space before the `?`.

  ```
  %bob What do you know about blobs.tif ?
  ```



  You can install `bia-bob` using conda/pip. It is recommended to install it into a conda/mamba environment. If you have never used conda before, please [read this guide first](https://biapol.github.io/blog/mara_lampert/getting_started_with_mambaforge_and_python/readme.html).

  It is recommended to install `bia-bob` in a conda-environment together with useful tools for bio-image analysis.

  ```
  conda env create -f https://github.com/haesleinhuepf/bia-bob/raw/main/environment.yml
  ```

  You can then activate this environment...

  ```
  conda activate bob_env
  ```

  OR install bob into an existing environment:

  ```
  pip install bia-bob
  ```



  For using LLMs from remote service providers, you need to set an [API key](https://en.wikipedia.org/wiki/API_key).
  API Keys are short cryptic texts such as "proj_sk_asdasdasd" which allow you to log into a remote service without entering your username and password. Many online serives require using API keys for billing; others enable you to use their free services only after obtaining an API key.
  This also means that you should not share your API key with others.
  In the following sections, you find links to a couple of LLM services providers that are compatible with bia-bob.
  After obtaining the key, you need to add it to the enviroment variables of your computer.
  On Windows, you can do this by 1) searching for "env" in the start menu, 2) clicking on "Edit the system environment variables",
  3) clicking on "Environment Variables", 4) clicking on "New" in the "System variables" section and adding a new variable with the name specified below (e.g. `OPENAI_API_KEY`) and the value of your API key.

  ![img.png](https://github.com/haesleinhuepf/bia-bob/raw/main/docs/images/api_keys.png)

  On Linux and MacOS, this is typically done by modifying a hidden `.bashrc` or `.zshrc` file in the home directory, e.g. like this:

  ```
  echo "export OPENAI_API_KEY='yourkey'" >> ~/.zshrc
  ```

  Note: After setting the environment variables, you need to restart your terminal and/or Jupyter Lab to make them work.

  See also further instructions on [this page](https://help.openai.com/en/articles/5112595-best-practices-for-api-key-safety).



  Create an [OpenAI API Key](https://openai.com/blog/openai-api) and add it to your environment variables named `OPENAI_API_KEY` as explained on

  You can then initialize Bob like this (optional, as that's default):
  ```
  from bia_bob import bob
  bob.initialize("gpt-4o-2024-08-06", vision_model="gpt-4o-2024-08-06")
  ```



  Create an [Anthropic API Key](https://www.anthropic.com/api) and add it to your environment variables named `ANTHROPIC_API_KEY`.

  You can then initialize Bob like this:
  ```
  from bia_bob import bob
  bob.initialize(model="claude-3-5-sonnet-20240620", vision_model="claude-3-5-sonnet-20240620")
  ```



  You can also [apply for an API Key](https://services.kisski.de/services/en/service/?service=2-02-llm-service.json) from the German Artificial Intelligence Service Center for Sensible and Critical Infrastructures who operates the [ChatAI](https://kisski.gwdg.de/leistungen/2-02-llm-service/) service.

  You can store it in an environment variable named `OPENAI_API_KEY` and use initialize bob like this:
  ```
  from bia_bob import bob
  bob.initialize(endpoint="https://chat-ai.academiccloud.de/v1",
                 model="meta-llama-3.1-70b-instruct")
  ```



  If you are using the models from [Github Models Marketplace](https://github.com/marketplace/models), please [create an GITHUB API key (with default settings)](https://github.com/settings/personal-access-tokens/new) and store it for accessing the models in an environment variable named `GH_MODELS_API_KEY`.

  You can then access the models like this:
  ```
  bob.initialize(
      endpoint='github_models',
      model='Phi-3.5-mini-instruct')
  ```



  If you are using the models hosted on [Microsoft Azure](https://azure.microsoft.com/), please store your API key for accessing the models in an environment variable named `AZURE_API_KEY`.

  You can then access the models like this:
  ```
  bob.initialize(
      endpoint='azure',
      model='Phi-3.5-mini-instruct')
  ```

  Alternatively, you can specify the endpoint directly, too:
  ```
  bob.initialize(
      endpoint='https://models.inference.ai.azure.com',
      model='Phi-3.5-mini-instruct')
  ```




  Custom endpoints can be used as well if they support the OpenAI API. Examples are [blablador](https://login.helmholtz.de/oauth2-as/oauth2-authz-web-entry) and [ollama](https://ollama.com/).
  An example is shown in [this notebook](https://github.com/haesleinhuepf/bia-bob/blob/main/demo/custom_endpoints.ipynb):

  For this, just install the openai backend as explained above (tested version: 1.5.0).
  * If you want to use ollama and e.g. the `codellama` model, you must run `ollama serve` from a separate terminal and then initialize bob like this:
  ```
  bob.initialize(endpoint='ollama', model='codellama')
  ```
  * If you want to use blablador, which is free for German academics, just get an API key as explained on
  [this page](https://sdlaml.pages.jsc.fz-juelich.de/ai/guides/blablador_api_access/) and store it in your environment as `BLABLADOR_API_KEY` variable.
  ```
  bob.initialize(
      endpoint='blablador',
      model='Mistral-7B-Instruct-v0.2')
  ```
  * Custom end points can be used as well, for example like this:
  ```
  bob.initialize(
      endpoint='http://localhost:11434/v1',
      model='codellama')
  ```



  Create a [Google API key](https://ai.google.dev/gemini-api/docs/api-key) and store it in the environment variable `GOOGLE_API_KEY`.

  ```
  pip install google-generativeai>=0.7.2
  ```

  You can then initialize Bob like this:
  ```
  from bia_bob import bob
  bob.initialize("gemini-1.5-pro-002")
  ```



  Note: This method is deprecated. Use gemini 1.5 as shown above.

  ```
  pip install google-cloud-aiplatform
  ```
  (Recommended google-cloud-aiplatform version >= 1.38.1)

  To make use of the Google Cloud API, you need to create a Google Cloud account [here](https://console.cloud.google.com/welcome/) and
  a project within the Google cloud (for billing) [here](https://console.cloud.google.com/projectcreate).
  You need to store authentication details locally as explained [here](https://cloud.google.com/docs/authentication/provide-credentials-adc#local-dev).
  This requires installing [Google Cloud CLI](https://cloud.google.com/sdk/docs/install). In very short: run the installer and when asked, activate the "Run gcloud init" checkbox. Or run 'gcloud init' from the terminal yourself. Restart the terminal window.
  After installing Google Cloud CLI, start a terminal and authenticate using:
  ```
  gcloud auth application-default login
  ```
  Follow the instructions in the browser. Enter your Project ID (not the name). If it worked the terminal should approximately look like this:

  ![img.png](https://github.com/haesleinhuepf/bia-bob/raw/main/docs/images/gcloud_auth.png)



  If you want to contribute to `bia-bob`, you can install it in development mode like this:

  ```
  git clone https://github.com/haesleinhuepf/bia-bob.git
  cd bia-bob
  pip install -e .
  ```



  If you are maintainer of a Python library and want to make BiA-bob aware of functions in your library, you can extend Bob's knowledge using [entry-points](https://packaging.python.org/en/latest/specifications/entry-points/). Add this to your library `setup.cfg`:
  ```

  [options.entry_points]
  bia_bob_plugins =
      plugin1 = your_library._bia_bob_plugins:list_bia_bob_plugins

  ```

  In the above mentioned `_bia_bob_plugins.py` define this function (and feel free to rename the function and the Python file):
  ```
  def list_bia_bob_plugins():
      """List of function hints for bia_bob"""
      return """
      * Computes the sum of a and b
      your_library.compute_sum(a:int,b:int) -> int

      * Determines the difference between a and b
      your_library.compute_difference(a:int, b:int) -> int

      """
  ```

  Note that the syntax should be pretty much as shown above: A bullet point with a short description and a code-snippet just below.
  You can also generate the `list_bia_bob_plugins` function as demonstrated in [this notebook](https://github.com/haesleinhuepf/stackview/blob/c87b59b896aeef9c0b60928b169027d1480c14e9/docs/generate_bia_bob_connector.ipynb).
  Please only list the most important functions. If the list of all plugins extending BiA-Bob becomes too long, the prompt will exceed the maximum prompt length.

  List of known Python libraries that provide extensions to Bob:
  * [pyclesperanto-prototype](https://github.com/clEsperanto/pyclesperanto_prototype)
  * [stackview](https://github.com/haesleinhuepf/stackview)

  (Feel free to extend this list by sending a pull-request)




  There are similar projects:
  * [jupyter-ai](https://github.com/jupyterlab/jupyter-ai)
  * [chatGPT-jupyter-extension](https://github.com/jflam/chat-gpt-jupyter-extension)
  * [chapyter](https://github.com/chapyter/chapyter/)
  * [napari-chatGPT](https://github.com/royerlab/napari-chatgpt)
  * [bioimageio-chatbot](https://github.com/bioimage-io/bioimageio-chatbot)
  * [Claude Engineer](https://github.com/Doriandarko/claude-engineer)
  * [BioChatter](https://github.com/biocypher/biochatter)
  * [aider](https://github.com/paul-gauthier/aider)
  * [OpenDevin](https://github.com/OpenDevin/OpenDevin)
  * [Devika](https://github.com/stitionai/devika)



  If you encounter any problems or want to provide feedback or suggestions, please create a thread on [image.sc](https://image.sc) along with a detailed description and tag @haesleinhuepf .


pkgId: e84c3ec6be60de6b11e622d8b427073326e8efde4a55c509fcf690944bc96ef7
name: python-biaplotter
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: A base napari plotter widget for interactive plotting
url: https://github.com/BiAPoL/biaplotter
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biaplotter-0.0.4-1.src.rpm
checksum_type: sha256
description:
  This [napari] plugin was generated with [Cookiecutter] using [@napari]'s [cookiecutter-napari-plugin] template.
  <!--
  Don't miss the full getting started guide to set up your new package:
  https://github.com/napari/cookiecutter-napari-plugin#getting-started
  and review the napari docs for plugin developers:
  https://napari.org/stable/plugins/index.html
  -->

  The full documentation with API and examples can be found [here](https://biapol.github.io/biaplotter/).

  * Make sure you have Python in your computer, e.g. download [miniforge](https://github.com/conda-forge/miniforge?tab=readme-ov-file#download).
  * Create a new environment, for example, like this:
  ```
  mamba create --name biaplotter-env python=3.9
  ```
  If you never used mamba/conda environments before, take a look at [this blog post](https://biapol.github.io/blog/mara_lampert/getting_started_with_mambaforge_and_python/readme.html).
  * **Activate** the new environment with `mamba`:
  ```
  mamba activate biaplotter-env
  ```
  * Install [napari](https://napari.org/stable/), e.g. via `mamba`:
  ```
  mamba install -c conda-forge napari pyqt
  ```
  Afterwards, install `biaplotter` via `pip`:
  ```
  pip install biaplotter
  ```
  To install latest development version :
  ```
  pip install git+https://github.com/BiAPoL/biaplotter.git
  ```

  Contributions are very welcome. Tests can be run with [tox], please ensure
  the coverage at least stays the same before you submit a pull request.

  Distributed under the terms of the [BSD-3] license,
  "biaplotter" is free and open source software

  If you encounter any problems, please [file an issue] along with a detailed description.
  [napari]: https://github.com/napari/napari
  [Cookiecutter]: https://github.com/audreyr/cookiecutter
  [@napari]: https://github.com/napari
  [MIT]: http://opensource.org/licenses/MIT
  [BSD-3]: http://opensource.org/licenses/BSD-3-Clause
  [GNU GPL v3.0]: http://www.gnu.org/licenses/gpl-3.0.txt
  [GNU LGPL v3.0]: http://www.gnu.org/licenses/lgpl-3.0.txt
  [Apache Software License 2.0]: http://www.apache.org/licenses/LICENSE-2.0
  [Mozilla Public License 2.0]: https://www.mozilla.org/media/MPL/2.0/index.txt
  [cookiecutter-napari-plugin]: https://github.com/napari/cookiecutter-napari-plugin
  [file an issue]: https://github.com/BiAPoL/biaplotter/issues
  [napari]: https://github.com/napari/napari
  [tox]: https://tox.readthedocs.io/en/latest/
  [pip]: https://pypi.org/project/pip/
  [PyPI]: https://pypi.org/


pkgId: 7e6e37c0c33a7f61144879affe85177cd405ea637838e75548c4101bffc1ef1a
name: python-biapy
arch: src
version: 3.5.6
epoch: 0
release: 1
summary: BiaPy: Bioimage analysis pipelines in Python
url: https://biapyx.github.io
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biapy-3.5.6-1.src.rpm
checksum_type: sha256
description:
  ![BiaPy logo](https://raw.githubusercontent.com/BiaPyX/BiaPy/master/img/biapy_logo.png)



  <p align="left">
      <a href="https://www.python.org/">
        <img src="https://img.shields.io/badge/Python-3.10-yellow.svg" /></a>
      <a href= "https://pytorch.org/">
        <img src="https://img.shields.io/badge/PyTorch-2.4-orange.svg" /></a>
      <a href= "https://pypi.org/project/biapy/">
        <img src="https://img.shields.io/pypi/v/biapy.svg?color=green" /></a>
      <a href= "https://github.com/BiaPyX/BiaPy/blob/master/LICENSE">
        <img src="https://img.shields.io/badge/License-MIT-blue.svg" /></a>
      <a href= "https://biapy.readthedocs.io/en/latest/">
        <img src="https://img.shields.io/badge/Doc-Latest-2BAF2B.svg" /></a>
      <a href= "https://www.biorxiv.org/content/10.1101/2024.02.03.576026v1">
        <img src="https://img.shields.io/badge/bioRxiv-Paper-bd2635.svg" /></a>
      <a href= "https://ieeexplore.ieee.org/abstract/document/10230593">
        <img src="https://img.shields.io/badge/IEEE-Paper-00629B.svg" /></a>
  </p>

  [![Code consistency](https://github.com/BiaPyX/BiaPy/actions/workflows/check_code_consistency.yml/badge.svg)](https://github.com/BiaPyX/BiaPy/actions/workflows/check_code_consistency.yml)

  🔥**NEWS**🔥: We have a new **preprint**! Check it out at bioRxiv: https://www.biorxiv.org/content/10.1101/2024.02.03.576026v1

  [BiaPy](https://biapyx.github.io) is an open source library and application that streamlines the use of common deep-learning workflows for a large variety of bioimage analysis tasks, including 2D and 3D [semantic segmentation](https://biapy.readthedocs.io/en/latest/workflows/semantic_segmentation.html), [instance segmentation](https://biapy.readthedocs.io/en/latest/workflows/instance_segmentation.html), [object detection](https://biapy.readthedocs.io/en/latest/workflows/detection.html), [image denoising](https://biapy.readthedocs.io/en/latest/workflows/denoising.html), [single image super-resolution](https://biapy.readthedocs.io/en/latest/workflows/super_resolution.html), [self-supervised learning](https://biapy.readthedocs.io/en/latest/workflows/self_supervision.html), [image classification](https://biapy.readthedocs.io/en/latest/workflows/classification.html) and [image to image translation](https://biapy.readthedocs.io/en/latest/workflows/image_to_image.html).

  BiaPy is a versatile platform designed to accommodate both proficient computer scientists and users less experienced in programming. It offers diverse and user-friendly access points to our workflows.

  This repository is actively under development by the [BiaPy Team](https://biapyx.github.io/about/), a group of contributors from different research institutions.

  ![BiaPy workflows](https://raw.githubusercontent.com/BiaPyX/BiaPy/master/img/BiaPy-workflow-readme.svg)


  Find a comprehensive overview of BiaPy and its functionality in the following videos:

  | [![BiaPy history and GUI demo](./img/BiaPy_presentation_and_demo_at_RTmfm.jpg)](https://www.youtube.com/watch?v=Gnm-VsZQ6Cc "BiaPy: a ready-to-use library for Bioimage Analysis Pipelines") <br> <span style="font-weight:normal">BiaPy history and GUI demo at [RTmfm](https://rtmfm.cnrs.fr/en/) by Ignacio Arganda-Carreras and Daniel Franco-Barranco.</span> |
  |-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | [![BiaPy presentation](./img/BiaPy-Euro-BioImaging-youtube.png)](https://youtu.be/6eYtX-ySpc0 "BiaPy: a ready-to-use library for Bioimage Analysis Pipelines") <br> BiaPy presentation at [Virtual Pub of Euro-BioImaging](https://www.eurobioimaging.eu/) by Ignacio Arganda-Carreras.                                                                      |                          |                          |                              |                           |



  You can also use BiaPy through our graphical user interface (GUI).

  ![BiaPy GUI](https://raw.githubusercontent.com/BiaPyX/BiaPy/master/img/BiaPy_GUI_main_page.png)



  - [Windows 64-bit](https://drive.google.com/uc?export=download&id=1iV0wzdFhpCpBCBgsameGyT3iFyQ6av5o)
  - [Linux 64-bit](https://drive.google.com/uc?export=download&id=13jllkLTR6S3yVZLRdMwhWUu7lq3HyJsD)
  - [macOS 64-bit](https://drive.google.com/uc?export=download&id=1fIpj9A8SWIN1fABEUAS--DNhOHzqSL7f)

  Project's page: [[BiaPy GUI](https://github.com/BiaPyX/BiaPy-GUI)]



  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |                                                                                                                                                             |
  |--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------------------------------------------------------------------------------:|
  | ```López-Cano, Daniel, et al. "Characterizing Structure Formation through Instance Segmentation" (2023).``` <br><br> This study presents a machine-learning framework to predict the formation of dark matter haloes from early universe density perturbations. Utilizing two neural networks, it distinguishes particles comprising haloes and groups them by membership. The framework accurately predicts halo masses and shapes, and compares favorably with N-body simulations. The open-source model could enhance analytical methods of structure formation by analyzing initial condition variations. ```BiaPy``` is used in the creation of the watershed approach. <br><br> [[Documentation (not yet)](https://biapy.readthedocs.io/en/latest)] [[Paper](https://arxiv.org/abs/2311.12110)] |                                                  ![](https://raw.githubusercontent.com/BiaPyX/BiaPy/master/img/halo_instances.png)                                                |
  | ```Franco-Barranco, Daniel, et al. "Current Progress and Challenges in Large-scale 3D Mitochondria Instance Segmentation." (2023).``` <br><br> This paper reports the results of the MitoEM challenge on 3D instance segmentation of mitochondria in electron microscopy images, held in conjunction with IEEE-ISBI 2021. The paper discusses the top-performing methods, addresses ground truth errors, and proposes a new scoring system to improve segmentation evaluation. Despite progress, challenges remain in segmenting mitochondria with complex shapes, keeping the competition open for further submissions. ```BiaPy``` is used in the creation of the MitoEM challenge baseline (U2D-BC). <br><br> [[Documentation](https://biapy.readthedocs.io/en/latest/tutorials/mitoem.html)] [[Paper](https://ieeexplore.ieee.org/document/10266382)] [[Toolbox](https://github.com/BiaPyX/TIMISE)] |                                                  ![](https://raw.githubusercontent.com/BiaPyX/BiaPy/master/img/complex_MOAS.png)                                                |
  | ```Backová, Lenka, et al. "Modeling Wound Healing Using Vector Quantized Variational Autoencoders and Transformers." 2023 IEEE 20th International Symposium on Biomedical Imaging (ISBI). IEEE, 2023.``` <br><br> This study focuses on time-lapse sequences of Drosophila embryos healing from laser-incised wounds. The researchers employ a two-stage approach involving a vector quantized variational autoencoder and an autoregressive transformer to model wound healing as a video prediction task. ```BiaPy``` is used in the creation of the wound segmentation masks. <br><br> [[Documentation](https://lenkaback.github.io/wound-healing-modeling/)] [[Paper](https://ieeexplore.ieee.org/document/10230571)] | ![](https://raw.githubusercontent.com/BiaPyX/BiaPy/master/img/wound_diagram_VQVAE.png) |
  | ```Andrés-San Román, Jesús A., et al. "CartoCell, a high-content pipeline for 3D image analysis, unveils cell morphology patterns in epithelia." Cell Reports Methods (2023)``` <br><br> Combining deep learning and 3D imaging is crucial for high-content analysis. CartoCell is introduced, a method that accurately labels 3D epithelial cysts, enabling quantification of cellular features and mapping their distribution. It's adaptable to other epithelial tissues. CartoCell method is created using ```BiaPy```. <br><br> [[Documentation](https://biapy.readthedocs.io/en/latest/tutorials/cartocell.html)] [[Paper](https://www.cell.com/cell-reports-methods/pdf/S2667-2375(23)00249-7.pdf)]                                                                                                                                                                                                                                                                  | <table>   <tr>     <td>![](https://raw.githubusercontent.com/BiaPyX/BiaPy/master/img/cyst_sample.gif) </td>     <td>![](https://raw.githubusercontent.com/BiaPyX/BiaPy/master/img/cyst_instance_prediction.gif) </td>   </tr> </table> |
  | ```Franco-Barranco, Daniel, et al. "Deep learning based domain adaptation for mitochondria segmentation on EM volumes."  Computer Methods and Programs in Biomedicine 222 (2022): 106949.``` <br><br> This study addresses mitochondria segmentation across different datasets using three unsupervised domain adaptation approaches, including style transfer, self-supervised learning, and multi-task neural networks. To ensure robust generalization, a new training stopping criterion based on source domain morphological priors is proposed. ```BiaPy``` is used for the implementation of the Attention U-Net. <br><br> [[Documentation](https://github.com/danifranco/EM_domain_adaptation)] [[Paper](https://www.sciencedirect.com/science/article/pii/S0169260722003315)]                                                                                                                  |                                                           ![](https://raw.githubusercontent.com/BiaPyX/BiaPy/master/img/domain_EM.jpg)                                                         |
  | ```Franco-Barranco, Daniel, et al. "Stable deep neural network  architectures for mitochondria segmentation on electron microscopy volumes." Neuroinformatics 20.2 (2022): 437-450.``` <br><br> Recent deep learning models have shown impressive performance in mitochondria segmentation, but often lack code and training details, affecting reproducibility. This study follows best practices, comprehensively comparing state-of-the-art architectures and variations of U-Net models for mitochondria segmentation, revealing their impact and stability. The research consistently achieves state-of-the-art results on various datasets, including EPFL Hippocampus, Lucchi++, and Kasthuri++. ```BiaPy``` is used for the implementation of the methods compared in the study. <br><br> [[Documentation](https://biapy.readthedocs.io/en/latest/tutorials/stable.html)] [[Paper](https://link.springer.com/article/10.1007/s12021-021-09556-1)]                                                                                                 |                                                       ![](https://raw.githubusercontent.com/BiaPyX/BiaPy/master/img/unet_attn_stable.png)                                                     |
  | ```Wei, Donglai, et al. "Mitoem dataset: Large-scale 3d mitochondria instance segmentation from em images." International Conference on Medical Image Computing and Computer-Assisted Intervention. Cham: Springer International Publishing, 2020.``` <br><br> Existing mitochondria segmentation datasets are small, raising questions about method robustness. The MitoEM dataset introduces larger 3D volumes with diverse mitochondria, challenging existing instance segmentation methods, highlighting the need for improved techniques. ```BiaPy``` is used in the creation of the MitoEM challenge baseline (U2D-BC). <br><br> [[Documentation](https://biapy.readthedocs.io/en/latest/tutorials/mitoem.html)] [[Paper](https://link.springer.com/chapter/10.1007/978-3-030-59722-1_7)] [[Challenge](https://mitoem.grand-challenge.org/)]                                                                                                                                                                             |                                               ![](https://raw.githubusercontent.com/BiaPyX/BiaPy/master/img/MitoEM_teaser_cable_length_split.png)                                                |



  | Name                                                                               | Role                                     | Affiliations                                                                                                                                                                                                                                                        |
  |------------------------------------------------------------------------------------|------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | [Daniel Franco-Barranco](https://BiaPyX.github.io/)                            | Creator, Implementation, Software design | <ul> <li> Dept. of Computer Science and Artificial Intelligence, University of the Basque Country (UPV/EHU)  </li> <li>  Donostia International Physics Center (DIPC) </li> </ul>                                                                                   |
  | [Lenka Backová](https://www.biofisika.org/en/about/people/lenka-backova)                     | Implementation                              | <ul> <li> Biofisika Institute </li> </ul>        |
  | [Aitor Gonzalez-Marfil](https://dipc.ehu.eus/es/dipc/personas/investigadores-en-formacion/aitor-gonzalez-marfil)                     | Implementation                              | <ul> <li> Dept. of Computer Science and Artificial Intelligence, University of the Basque Country (UPV/EHU) </li> <li> Donostia International Physics Center (DIPC) </li> </ul>        |
  | [Ignacio Arganda-Carreras](https://www.ikerbasque.net/es/ignacio-arganda-carreras) | Supervision, Implementation              | <ul> <li> Dept. of Computer Science and Artificial Intelligence, University of the Basque Country (UPV/EHU) </li> <li> Donostia International Physics Center (DIPC)  </li> <li> IKERBASQUE, Basque Foundation for Science </li> <li>Biofisika Institute </li> </ul> |
  | [Arrate Muñoz-Barrutia](https://image.hggm.es/es/arrate-munoz)                     | Supervision                              | <ul> <li> Dept. de Bioingenieria, Universidad Carlos III de Madrid </li> </ul>  |




  | Name                                                                                               | Role                        | Affiliations                                                                                                                                                                                                                                                                                                                                                     |
  |----------------------------------------------------------------------------------------------------|-----------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | [Jesús Ángel Andrés-San Román](https://scholar.google.es/citations?user=OfDu4q4AAAAJ&hl=en&oi=sra) | Implementation              | <ul> <li>Instituto de Biomedicina de Sevilla (IBiS), Hospital Universitario Virgen del Rocío/CSIC/Universidad de Sevilla and Dept. de Biología Celular, Facultad de Biología, Universidad de Sevilla </li> <li> Biomedical Network Research Centre on Neurodegenerative Diseases (CIBERNED) </li> </ul>                                                    |
  | [Pedro Javier Gómez Gálvez](https://scholar.google.es/citations?user=aWeyQGUAAAAJ&hl=en&oi=sra)    | Supervision, Implementation | <ul> <li>Instituto de Biomedicina de Sevilla (IBiS), Hospital Universitario Virgen del Rocío/CSIC/Universidad de Sevilla and Dept. de Biología Celular, Facultad de Biología, Universidad de Sevilla </li> <li> MRC Laboratory of Molecular Biology </li> <li> Department of Physiology, Development and Neuroscience, University of Cambridge </li> </ul> |
  | [Luis M. Escudero](http://www.scutoids.es/)                                                        | Supervision                 | <ul> <li>Instituto de Biomedicina de Sevilla (IBiS), Hospital Universitario Virgen del Rocío/CSIC/Universidad de Sevilla and Dept. de Biología Celular, Facultad de Biología, Universidad de Sevilla </li> <li> Biomedical Network Research Centre on Neurodegenerative Diseases (CIBERNED) </li> </ul>                                                    |
  | [Iván Hidalgo Cenalmor](https://henriqueslab.github.io/team/2023-03-16-IH/)                        | Implementation              | <ul> <li> Optical cell biology group, Instituto Gulbenkian de Ciência, Oerias, Portugal </li> </lu>                                                                                                                                                                                                                                                              |
  | [Donglai Wei](https://donglaiw.github.io/)                                                        | Supervision                 | <ul> <li>Boston College</li> </ul>  |
  | [Clément Caporal](https://scholar.google.com/citations?hl=en&user=R0fXJGUAAAAJ)                                                        | Implementation                 | <ul> <li>Laboratoire d’Optique et Biosciences, CNRS, Inserm, Ecole Polytechnique</li> </ul>  |
  | [Anatole Chessel](https://scholar.google.com/citations?hl=en&user=GC8aiVsAAAAJ)                                                        | Supervision                 | <ul> <li>Laboratoire d’Optique et Biosciences, CNRS, Inserm, Ecole Polytechnique</li> </ul>  |


  Please note that BiaPy is based on a publication. If you use it successfully for your research please be so kind to cite our work:
  ```
  Franco-Barranco, D., Andrés-San Román, J.A., Gómez-Gálvez, P., Escudero, L.M., Muñoz-Barrutia, A. and
  Arganda-Carreras, I., 2023, April. BiaPy: a ready-to-use library for Bioimage Analysis Pipelines.
  In 2023 IEEE 20th International Symposium on Biomedical Imaging (ISBI) (pp. 1-5). IEEE.
  ```

rpm_license:
  MIT License  Copyright (c) 2022 Daniel Franco-Barranco  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: ee9459a69710fe5c1eade1d6f7c33b5b6ce838f717daf9d6f1d053c66b55624a
name: python-bias-detector
arch: src
version: 0.0.13
epoch: 0
release: 1
summary: Bias Detector is a python package for detecting bias in machine learning models
url: https://github.com/intuit/bias-detector
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bias-detector-0.0.13-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/intuit/bias-detector/branch/main/graph/badge.svg)](https://codecov.io/gh/intuit/bias-detector)
  [![CircleCI](https://circleci.com/gh/intuit/bias-detector.svg?style=shield)](https://circleci.com/gh/intuit/bias-detector)
  [![License](https://img.shields.io/github/license/intuit/bias-detector)](https://raw.githubusercontent.com/intuit/bias-detector/master/LICENSE)
  [![PyPI version](https://img.shields.io/pypi/v/bias-detector)](https://pypi.org/project/bias-detector)
  [![Downloads](https://pepy.tech/badge/bias-detector)](https://pepy.tech/project/bias-detector)
  <!--[![PiPi stats](https://img.shields.io/pypi/dm/bias-detector.svg)](https://pypistats.org/packages/bias-detector)-->
  <!--[![GitHub release](https://img.shields.io/github/release/intuit/bias-detector.svg)](https://github.com/intuit/bias-detector/releases)-->


  [//]: # (description)
  Bias Detector is a python package for detecting gender/race bias in binary classification models.

  Based on first and last name/zip code the package analyzes the probability of the user belonging to different genders/races. Then, the model predictions per gender/race are compared using various bias metrics.

  Using this package you will be able to gain insight into whether your model is biased or not, and if so, how much bias was found.

  The Bias Detector is based on statistical data from the US, and therefore it performs best with US originated data. However, it is possible to optimize the package for other countries by adding the relevant statistical information. If you have such data, you can open a Pull Request to add it to the package.

  If you have any questions please [let us know](https://github.com/intuit/bias-detector/discussions). You can learn more about our research [here](https://www.sciencedirect.com/science/article/pii/S2666659621000135).


  There are many metrics which can possibly be used to detect Bias, we currently support the following three:
  1. Statistical Parity - tests whether the probability of 2 groups to be classified as belonging to the positive class by the model is equal.
  2. Equal Opportunity - tests whether the True Positive Rates of 2 groups are equal (how likely is the model to predict correctly the positive class for each group).
  2. Predictive Equality - tests whether there False Positive Rates of 2 groups are equal (how likely is the model to predict incorrectly the positive class for each group).



  **Install the package**

  ```
  !pip install bias-detector
  ```

  **Create a bias detector instance:**

  ```
  from bias_detector.BiasDetector import BiasDetector
  bias_detector = BiasDetector(country='US')
  ```

  **Generate bias report:**

  ```
  bias_report = bias_detector.get_bias_report(first_names=first_names, last_names=last_names, zip_codes=zip_codes, y_true=y_true, y_pred=y_pred)
  ```

  **Visualize the bias report:**

  ```
  bias_report.plot_summary()
  ```

  <img src="https://raw.githubusercontent.com/intuit/bias-detector/master/bias_detector/static/bias_report_summary_plot_statistical_parity.png" width="66%"/>
  <img src="https://raw.githubusercontent.com/intuit/bias-detector/master/bias_detector/static/bias_report_summary_plot_equal_opportunity.png" width="66%"/>
  <img src="https://raw.githubusercontent.com/intuit/bias-detector/master/bias_detector/static/bias_report_summary_plot_preditive_equality.png" width="66%"/>

  ```
  bias_report.print_summary()
  ```

  <ul><li>Statistical Parity:</li>We observed the following statistically significant differences (𝛼=0.01):<ul><li>P(pred=1|Male)-P(pred=1|Female)=0.55-0.49=0.053±0.026 (p-value=1e-07)</li></ul><li>Equal Opportunity:</li>We observed the following statistically significant differences (𝛼=0.01):<ul><li>TPR<sub>Male</sub>-TPR<sub>Female</sub>=0.56-0.51=0.047±0.036 (p-value=0.00097)</li></ul><li>Predictive Equality:</li>We observed the following statistically significant differences (𝛼=0.01):<ul><li>FPR<sub>Male</sub>-FPR<sub>Female</sub>=0.54-0.48=0.06±0.036 (p-value=2e-05)</li></ul></ul>

  ```
  bias_report.plot_groups()
  ```

  <img src="https://raw.githubusercontent.com/intuit/bias-detector/master/bias_detector/static/bias_report_gender_pie.png" width="66%" />
  <img src="https://raw.githubusercontent.com/intuit/bias-detector/master/bias_detector/static/bias_report_race_pie.png" width="66%" />

  **Show gender/race correlation with model features:**

  ```
  bias_detector.get_features_groups_correlation(first_names=first_names, last_names=last_names, zip_codes=zip_codes, features=features)
  ```
  Sample output from the [Titanic demo](https://github.com/intuit/bias-detector/blob/main/demos/titanic/titanic-bias-detection.ipynb):
  <table>
      <thead>
      <tr>
          <th></th>
          <th>male_correlation</th>
          <th>female_correlation</th>
          <th>white_correlation</th>
          <th>black_correlation</th>
          <th>api_correlation</th>
          <th>hispanic_correlation</th>
          <th>native_correlation</th>
      </tr>
      </thead>
      <tbody>
      <tr>
          <th>ticket_class</th>
          <td>-0.243730</td>
          <td>0.010038</td>
          <td>-0.122978</td>
          <td>-0.152287</td>
          <td>0.128161</td>
          <td>-0.003452</td>
          <td>-0.029846</td>
      </tr>
      <tr>
          <th>age</th>
          <td>0.234712</td>
          <td>-0.168692</td>
          <td>0.165937</td>
          <td>-0.059513</td>
          <td>-0.044503</td>
          <td>-0.058893</td>
          <td>0.036010</td>
      </tr>
      <tr>
          <th>num_of_siblings_or_spouses_aboard</th>
          <td>0.027651</td>
          <td>0.025737</td>
          <td>0.029292</td>
          <td>0.066896</td>
          <td>-0.061708</td>
          <td>-0.072092</td>
          <td>0.138135</td>
      </tr>
      <tr>
          <th>num_of_parents_or_children_aboard</th>
          <td>0.057575</td>
          <td>0.042770</td>
          <td>0.048623</td>
          <td>0.099354</td>
          <td>-0.064993</td>
          <td>-0.100496</td>
          <td>0.064185</td>
      </tr>
      <tr>
          <th>fare</th>
          <td>0.053703</td>
          <td>0.071300</td>
          <td>0.076330</td>
          <td>0.061158</td>
          <td>-0.001893</td>
          <td>-0.067631</td>
          <td>0.058121</td>
      </tr>
      <tr>
          <th>embarked_Cherbourg</th>
          <td>-0.073627</td>
          <td>-0.013599</td>
          <td>-0.093890</td>
          <td>-0.075407</td>
          <td>-0.007720</td>
          <td>0.124144</td>
          <td>-0.020478</td>
      </tr>
      <tr>
          <th>embarked_Queenstown</th>
          <td>-0.019206</td>
          <td>0.169752</td>
          <td>0.110737</td>
          <td>-0.049664</td>
          <td>-0.049379</td>
          <td>0.011407</td>
          <td>-0.054550</td>
      </tr>
      <tr>
          <th>embarked_Southampton</th>
          <td>0.082538</td>
          <td>-0.090631</td>
          <td>0.011149</td>
          <td>0.100265</td>
          <td>0.038108</td>
          <td>-0.116438</td>
          <td>0.050909</td>
      </tr>
      <tr>
          <th>sex_female</th>
          <td>-0.327044</td>
          <td>0.615262</td>
          <td>0.047330</td>
          <td>0.073640</td>
          <td>-0.051959</td>
          <td>0.074259</td>
          <td>0.011737</td>
      </tr>
      <tr>
          <th>sex_male</th>
          <td>0.327044</td>
          <td>-0.615262</td>
          <td>-0.047330</td>
          <td>-0.073640</td>
          <td>0.051959</td>
          <td>-0.074259</td>
          <td>-0.011737</td>
      </tr>
      </tbody>
  </table>

  **Fuzzy extraction of first/last names from emails:**

  ```
  bias_detector.fuzzily_get_emails_full_names(emails)
  ```

  This method will return a DataFrame with first_name and last_name columns fuzzily extracted from the users emails. Note that the accuracy of this method varies between emails and data sets.

  Sample output for synthetic emails:

  <table>
      <thead>
      <tr>
          <th>email</th>
          <th>first_name</th>
          <th>last_name</th>
      </tr>
      </thead>
      <tbody>
      <tr>
          <th>holleybeverly@gmail.com</th>
          <td>holley</td>
          <td>beverly</td>
      </tr>
      <tr>
          <th>breweradrienne@gmail.com</th>
          <td>adrienne</td>
          <td>brewer</td>
      </tr>
      <tr>
          <th>craigreed@gmail.com</th>
          <td>craig</td>
          <td>reed</td>
      </tr>
      <tr>
          <th>battagliahenry@gmail.com</th>
          <td>henry</td>
          <td>battaglia</td>
      </tr>
      <tr>
          <th>apaget@gmail.com</th>
          <td></td>
          <td>paget</td>
      </tr>
      <tr>
          <th>briana@gmail.com</th>
          <td>briana</td>
          <td></td>
      </tr>
      <tr>
          <th>apena@gmail.com</th>
          <td></td>
          <td>pena</td>
      </tr>
      <tr>
          <th>jacka@gmail.com</th>
          <td></td>
          <td>jacka</td>
      </tr>
      <tr>
          <th>mattiea@gmail.com</th>
          <td>mattie</td>
          <td></td>
      </tr>
      <tr>
          <th>patricia_calder@gmail.com</th>
          <td>patricia</td>
          <td>calder</td>
      </tr>
      </tbody>
  </table>




  See [CONTRIBUTING.md](https://github.com/intuit/bias-detector/blob/main/CONTRIBUTING.md).


  1. Elhanan Mishraky, Aviv Ben Arie, Yair Horesh, Shir Meir Lador, 2021. Bias Detection by Using Name Disparity Tables Across Protected Groups, DOI: 10.1016/j.jrt.2021.100020
  2. Ninareh Mehrabi, Fred Morstatter, Nripsuta Saxena, Kristina Lerman, Aram Galstyan, 2019. A Survey on Bias and Fairness in Machine Learning.
  3. Moritz Hardt, Eric Price, Nathan Srebro, 2016. Equality of Opportunity in Supervised Learning.
  4. Ioan Voicu (2018) Using First Name Information to Improve Race and Ethnicity Classification, Statistics and Public Policy, 5:1, 1-13, DOI: 10.1080/2330443X.2018.1427012


pkgId: f77572d1f6f1bf8e34182217fb273e9964ff6abda907d302eb1a67388e6468c9
name: python-bib-watch
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: A LaTeX bibliography manager that automatically organizes references
url: https://github.com/yourusername/bibmanager
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bib-watch-1.0.2-1.src.rpm
checksum_type: sha256
description:
  A real-time LaTeX bibliography management tool that automatically organizes and updates your references.



  - Real-time monitoring of .tex file citation changes
  - Automatic .bib file organization
  - Citation context tracking
  - Citation statistics
  - Maintains citation order
  - Multiple citation commands support



  - Python 3.x



  - `bibtexparser`
  - `watchdog`



  The program organizes `references.bib` into:



  - Last update time
  - Reference counts
  - File statistics



  - Sorted by first appearance
  - Citation frequency
  - Context information
  - Line numbers



  - Preserved for future use
  - Original entry format





  To process files in the current directory, use:

  ```bash
  bibmanager
  ```



  To enable watch mode, which automatically updates the bibliography as changes occur, use:

  ```bash
  bibmanager -w
  ```



  To specify a directory for managing LaTeX projects, use:

  ```bash
  bibmanager -d /path/to/latex/project
  ```





  - DOI lookup and metadata completion
  - PDF file management
  - Reference format validation





  - Ensure Python is installed and in PATH
  - Restart terminal after installation



  - Try running with administrator privileges
  - Check internet connection
  - Update pip: `python -m pip install --upgrade pip`



  - Ensure .tex files are UTF-8 encoded
  - Check for special characters



  1. Fork the repository
  2. Create your feature branch
  3. Commit your changes
  4. Submit a pull request



  For support:

  - Open an issue
  - Provide error messages
  - Include minimal example



  This software is protected by copyright law. All rights reserved.

  No part of this software may be reproduced, modified, distributed, or republished without prior written permission from the author.

  Commercial use and redistribution are strictly prohibited.

  Made with ❤️ for LaTeX users


pkgId: 087e32b8dac73f564e16fae096f866b51228b6eef760323fc676cf66b906d08e
name: python-bib2tex
arch: src
version: 0.3.5
epoch: 0
release: 1
summary: Create a subset of BibTeX entries based on an author's name and covert it into a LaTeX list.
url: https://codeberg.org/Cs137/bib2tex
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bib2tex-0.3.5-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/bib2tex.svg)](https://pypi.org/project/bib2tex/)



  A Python package to create a subset of BibTeX entries based on an author's name
  (and an entrytype). The result is converted into a LaTeX list in which the author
  can get highlighted with an underline. The list is sorted from new to old.

  The motivation for writing this package was to create a tool that generates lists
  with own publications for e.g. a curriculum vitae.




  Let us assume the BibTeX file `data.bib` contained the following entry in addition
  to entries by other authors:

  ```bibtex
  @TechReport{Rossum1995,
    author           = {van Rossum, Guido},
    institution      = {Centrum voor Wiskunde en Informatica (CWI)},
    title            = {Python tutorial},
    year             = {1995},
    address          = {Amsterdam},
    month            = may,
    number           = {CS-R9526},
    groups           = {python},
    url              = {https://ir.cwi.nl/pub/5007/05007D.pdf},
  }
  ```

  To obtain a list with all entries containing *Guido van Rossum* in your BibTeX
  data, simply call bib2tex and provide the path to the `data.bib` file, a prompt
  will request an author name:

  ```text
  bib2tex -i data.bib
  Enter the author name for filtering BibTeX entries: Rossum
  ```

  The resulting LaTeX list is stored in the file `rossum.tex` in the current working
  directory and contains the following:

  ```tex
  \begin{itemize}
    \item G.~van Rossum: ``Python tutorial'', Centrum voor Wiskunde en Informatica (CWI), 1995.
  \end{itemize}
  ```

  If the BibTeX data contains multiple entries for the author, they will be added
  as items to the LaTeX itemize environment.

  You can specify a BibTeX entry type to narrow down the result list, or define
  [custom types](https://codeberg.org/Cs137/bib2tex/src/branch/dev/README.md#custom-types)
  to obtain a list with a subset of a certain BibTeX entry type.
  Furthermore, [format schemes](https://codeberg.org/Cs137/bib2tex/src/branch/dev/README.md#format-scheme)
  can be added to adjust the formatting of the LaTeX item string if desired.
  There are more options to influence the conversion and run the command withouth
  any need for an interaction.




  Install `bib2tex` from the *Python Package Index* using `pip`:

  ```bash
  pip install bib2tex
  ```



  - [click](https://pypi.org/project/click/) (to provide the CLI)






  The CLI can be called with the command `bib2tex`, if the package is installed.
  Run it with the `--help` option to get the following usage information and a list
  of all options:

  ```text
  Usage: bib2tex [OPTIONS]

    bib2tex - A command line utility to generate LaTeX lists from BibTeX data.

    Sorted lists are generated based on an author's name and entry types
    (optional). They are either merged into a LaTeX item environment and written
    into a file, or stored in individual files as LaTeX item environment.

    The files are written to the output directory and are named based on the
    filter options. If no entry type is declared, the filename is 'author.tex',
    while it is 'author_entrytype.tex' if you filter for one entry type, and
    'author_entrytype1-entrytype2...entrytypeN.tex' if multiple entry types are
    declared.

  Options:
    -i, --bibtex-path FILE      (input) Path to the BibTeX file.  [default:
                                /path/defined/as/BIB/env/var; required]
    -o, --output-dir DIRECTORY  Path to output directory for LaTeX files.
                                [default: .; required]
    -a, --author TEXT           Author name for filtering entries.  [required]
    -c, --case-sensitive        Case sensitive filtering.
    -d, --definitions FILE      Path to a JSON file with custom type
                                definitions.
    -e, --entry-type TEXT       Specify entry type for filtering; declare
                                multiple times for batch conversion.
    -f, --force                 Perform the conversion without confirmations.
    -m, --merge                 Merge individual lists into one list (batch).
    -r, --reverse               Sort entries from old to new.
    -s, --format-scheme TEXT    Scheme name for LaTeX item formatting.
    -u, --underline             Underline the author in the LaTeX item.
    -v, --verbose               Print verbose output.
    --item TEXT                 Options for LaTeX item, e.g. "[--]".
    --itemize TEXT              Options for LaTeX itemze, e.g. "[itemsep=3pt]".
    --schemes-dir DIRECTORY     Path to a folder holding custom format schemes.
    --version                   Show the version and exit.
    -h, --help                  Show this message and exit.

    by Cs137, 2024 - development on Codeberg: https://codeberg.org/Cs137/bib2tex
   ```



  In order to obtain all articles for the author *MyName* from the default BibTeX
  file, call the CLI as follows:

  ```bash
  bib2tex -a MyName -e article
  ```

  The generated list is stored in the file `myname.tex` and the example assumes
  that the `--bibtex-path` is defined via the environment variable `BIB`.
  Provide a path to it if the variable is undefined (`-i path/to/example.bib`).
  Call the CLI with the `--verbose | -v` option to show log messages in the shell.




  The path to the default BibTeX file can be defined with the environment variable `BIB`.



  A format scheme is used to define the structure of BibTeX entries when converted
  to LaTeX list items. Default format schemes exist for all valid BibTeX types, and
  they are sourced from the directory [`format_schemes`](https://codeberg.org/Cs137/bib2tex/src/branch/dev/bib2tex/format_schemes).

  Custom format schemes can be defined in a JSON file named with the format scheme
  name. If a format scheme is missing for a certain entry type, the default format
  scheme is taken into account. The format scheme string consists of valid
  capitalised BibTeX tags wrapped in `<>` and is defined for each BibTeX entry type.

  Underneath is a typical format scheme string, keep in mind that the availability
  of BibTeX tags depends on the entry type when defining new format schemes.

  ```text
  <AUTHOR>: ``<TITLE>'', <YEAR>, DOI: \href{https://doi.org/<DOI>}{<DOI>}.
  ```

  Feel free to create a pull request to add new format schemes, and ensure your
  schemes follow the required structure and placeholders.



  In order to allow more complex filter tasks, custom entry types are introduced.
  A custom type is based on a valid BibTeX entry type and has certain keywords in
  defined BibTeX fields.

  Create a JSON file containing a dictionary for each custom type you want to declare.
  The dictionaries must contain the properties shown in the example underneath.
  If a file with custom definitions is provided to the CLI, it accepts the custom
  types declared in it as entry types to filter for as well.

  ```json
  {
    "dataset": {
      "bibtex_type": "misc",
      "format_schemes": {
        "default": "<AUTHOR>: ``<TITLE>'', <YEAR>, <LICENSE>, DOI: \\href{https://doi.org/<DOI>}{<DOI>}."
      },
      "search_strings": {
        "notes": "data set"
      }
    }
  }
  ```

  The key `search_strings` is assigned to a dictionary, which holds a mapping in
  order to identify custom entries in entries of the specified `bibtex_type`.
  In the sample above, an entry type is considered as `dataset`, if it is a BibTeX
  entry of type `misc` and the BibTeX field `notes` contains the string `data set`,
  multiple `search_strings` can be defined in the dictionary.

  Format scheme strings can be declared in the `format_schemes` dictionary for the
  custom type. The key corresponds to the name for the format scheme, ensure to
  provide a default scheme for each custom type declared. Those may contain field
  names that are not conform with BibTeX, like `license` in the example above.

  Assuming the file `my_types.json` contains the example shown above and the BibTeX
  data contain entries corresponding to the defined search strings, those could be
  converted into a LaTeX list using the following command:

  ```bash
  bib2tex -a MyName -d my_types.json -e dataset -v
  ```




  - Author's first names are always listed with initials, this is currently not configurable.
  - Check the [`bib2tex.converter:to_latex`](https://codeberg.org/Cs137/bib2tex/src/branch/dev/bib2tex/converter.py)
    function for a conversion without CLI. (Make click/CLI optional ?)




  All notable changes to this project are documented in the
  [`CHANGELOG.md`](https://codeberg.org/Cs137/bib2tex/src/branch/dev/CHANGELOG.md) file.



  This project is licensed under the MIT License - see the
  [`LICENSE`](https://codeberg.org/Cs137/bib2tex/src/branch/dev/LICENSE) file for details.


pkgId: 4a99b384ffb20e7d7f5f68a3506654b801373ab445a5ad0b14af4b8276d7016f
name: python-bibclean
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: A simple BibTex file checker and cleaner.
url: https://pypi.org/project/bibclean/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibclean-0.8.0-1.src.rpm
checksum_type: sha256
description:
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
  [![codecov](https://codecov.io/gh/mscheltienne/bibclean/branch/main/graph/badge.svg?token=RX2lXKFDUn)](https://codecov.io/gh/mscheltienne/bibclean)
  [![tests](https://github.com/mscheltienne/bibclean/actions/workflows/pytest.yml/badge.svg?branch=main)](https://github.com/mscheltienne/bibclean/actions/workflows/pytest.yml)
  [![doc](https://github.com/mscheltienne/bibclean/actions/workflows/doc.yml/badge.svg?branch=main)](https://github.com/mscheltienne/bibclean/actions/workflows/doc.yml)
  [![PyPI version](https://badge.fury.io/py/bibclean.svg)](https://badge.fury.io/py/bibclean)
  [![Downloads](https://static.pepy.tech/badge/bibclean)](https://pepy.tech/project/bibclean)



  A simple BibTex file checker and cleaner. The documentation can be found
  [here](https://mscheltienne.github.io/bibclean/dev/index.html).

rpm_license:
  MIT License  Copyright (c) 2022 Mathieu Scheltienne  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: dbb699dcba39beb8afbe7394a15e58f61bf820440490b9849772b921d1e47ac0
name: python-bibdatamanagement
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: Package to read .bib file annotations and retrieve values from it
url: https://gitlab.epfl.ch/ipese/bibdatamanagement/bibdata-package/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibdatamanagement-1.0.5-1.src.rpm
checksum_type: sha256
description:
  The goal is to provide an easy way to extract in python custom data set in the *annote* field of a bib file.



  **BibdataManagement** library is stored in IPESE pypi server located on https://ipese-internal.epfl.ch/registry/pypi. and https://pypi.org/project/bibdatamanagement/

  To include the library in your projects, do the following in _requirements.txt_:
  1. Include the package
  ```
  bibdatamanagement >= 0.6.0
  ```

  Otherwise, the package can be installed by using a _pip_ command.
  ```
  pip install bibdatamanagement
  ```



  The package is designed to extract data in a specific format. The initial development was made for technologies parameter
  used to model it.
  ```
  +- ENTRY # row_key:set: general description of tech
  param1 = min:value1:max [unit1] # short_name: a comment about the param and its value
  param2 = value2 [unit2]
  +- /ENTRY
  ```
  Where the fields described as follows:
  |Fields | Description | Mandatory|
  |--- | --- | ---|
  |ENTRY | The name of the tech to which the parameters belong | True|
  |row_key | An identifier | False|
  |set | Use to retrieve all values from a user (e.g. all values for   *scenario_oil*) | False|
  |general_description | A comment on the tech or on the paper | False|
  |param | Name of the parameter characterised | False|
  |value | Value of the parameter | True|
  |min | Minimal value that the parameter can have | False|
  |max | Maximal value that the parameter can have | False|
  |unit | Unit of the parameter | True|

  The minimal information to provide is the `+- ENTRY       +- /ENTRY`. The fields after the _#_ are optional, as well as
  the min and max values.

  > Nb: spaces in the key/value line are for readability but are not required



  The minimal workflow to access the data in the _.bib_ is the following.

  ```python
  from bibdata_management.bibdata_management import BibDataManagement
  bib_file = 'your_path/your_file.bib'
  bibdata = BibDataManagement(bib_file)
  df_bib = bibdata.get_data(tech_name='YOUR_ENTRY', set_name='YOUR_SET')
  ```

  One can also add a _.csv_ file that contains the default value for parameters description (short name, long name, description).
  ```{python}
  bibdata = BibDataManagement(bib_file, 'your_default_file.csv')
  ```



  More information on the fields and the methods is available in the [documentation website](https://bibdata.readthedocs.io/en/latest/)



  All suggestions or implementation must be tracked with dedicated issues and reported at the [project GitHub](https://github.com/IPESE/BibDataManagement/issues)

  If you want to make the format evolve or implement a new python function, create an issue before anything else.



  - [Joseph Loustau](mailto:joseph.loustau@gmail.com), IPESE


pkgId: ade139b5a8229a20149ae4636c5507f72a54aded899ef587dcfb6b510cc4c08f
name: python-bibfish
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: Extract entries from a .bib file that are cited in a .tex file
url: https://github.com/jwcarr/bibfish
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibfish-0.3.3-1.src.rpm
checksum_type: sha256
description:
  Bibfish generates a local BibTeX file from a central BibTeX database based on the citations found in a LaTeX file. This is useful if you want to maintain a single master BibTeX file (or several) and automatically generate a separate, independent BibTeX file for each manuscript you're working on. It is similar to [Bibexport](https://www.ctan.org/tex-archive/biblio/bibtex/utils/bibexport/) and [Makebib](https://gitlab.com/Verner/makebib), except Bibfish is not dependent on any particular LaTeX tool and is therefore agnostic about your choice of bibliographic software (BibTeX vs. BibLaTeX, etc.) or general typesetting pipeline.


pkgId: e1fbd9f2b5a2f115ee1686e43eae45526ca61a0e9ddcf5f4a7e4a65af69e5c9e
name: python-bibin
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: bibin - trash files and folders
url: https://gitlab.com/hydrargyrum/bibin
rpm_license: WTFPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibin-0.1.0-1.src.rpm
checksum_type: sha256
description:
  Trash/Untrash files and folders in command-line or as a library.
  Follows relevant [freedesktop spec](https://specifications.freedesktop.org/trash-spec/1.0/).



      pipx install bibin



  TODO



  TODO



  - supports non-home dir trashes (for example on different partitions or removable drives)



  bibin is licensed under [WTFPLv2](COPYING.WTFPL).


pkgId: 3673144589e177c536a264abc39a613a8e64eac945df62300d5c41b01e0f4348
name: python-biblebot
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: Scraper for KBU students
url: https://github.com/rekyungmin/biblebot-scraper
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biblebot-0.4.3-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">Biblebot Scraper</h1>
  <p align="center">
  <a href="https://www.python.org/downloads/release/python-370/"><img alt="Python" src="https://img.shields.io/badge/python-3.7-blue?logo=python&logoColor=white"></a>
  <a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>
  </p>

  성서봇 스크래이퍼는 한국성서대학교와 연관된 정보를 수집할 수 있는 파이썬 패키지입니다.

  이 패키지는 다섯 가지 웹사이트에 대한 스크래이퍼를 제공합니다.

  1. [한국성서대학교 인트라넷](https://kbuis.bible.ac.kr/) 스크래이퍼
  2. [한국성서대학교 LMS](https://lms.bible.ac.kr/) 스크래이퍼
  3. [한국성서대학교 홈페이지](https://www.bible.ac.kr/) 스크래이퍼
  4. [OKPOS 마일리지 시스템](https://asp.netusys.com/) 스크래이퍼
  5. [한국성서대학교 도서관](https://lib.bible.ac.kr/) 스크래이퍼




  ```
  $ pip install 'biblebot[http]'
  ```




  - `beautifulsoup4`: html과 xml 에서 데이터를 추출하기 위해 사용합니다.
  - `aiohttp`: HTTP 요청을 위해 사용합니다. (OPTIONAL)


  HTTP 요청을 위해 HTTP 요청 패키지가 필요합니다. `aiohttp` 또는 `requests` 패키지가 존재할 경우 자동으로 인식하여 사용합니다.

  그 외의 HTTP 요청 패키지를 이용하고 싶다면 `BaseRequest` 추상클래스를 상속받아 구현한 뒤, `HTTPClient.set`을 이용하여 등록해 사용할 수 있습니다.





  [APIs document](docs/APIs.md)







  ````python
  import asyncio
  from pprint import pprint

  from biblebot import KbuAPI


  async def main():
      resp = await KbuAPI.MainNotice.fetch(page=2)  # 공지사항 2페이지
      result = KbuAPI.MainNotice.parse(resp)
      pprint(result.data)

  asyncio.run(main())
  ````

  **Output:**

  ```json
  {
      "notice": [
          {
              "seq": "3742",
              "title": "[대학원 입시] 2020학년도 후기 한국성서대학교 대학원 신입생 모집",
              "author": "장성희",
              "date": "2020-07-31",
              "url": "https://www.bible.ac.kr/ko/life/notice/view/46649?p=2"
          },
          {
              "seq": "3741",
              "title": "[기초교육원] 2020-2학기 수강신청 기초교육원, 영어교육센터 공지사항 안내",
              "author": "김다윗",
              "date": "2020-07-30",
              "url": "https://www.bible.ac.kr/ko/life/notice/view/46645?p=2"
          },
          {
              "seq": "3740",
              "title": "[학적] 2020-2학기 적용 융합모듈 교육과정 승인자 발표",
              "author": "김희",
              "date": "2020-07-30",
              "url": "https://www.bible.ac.kr/ko/life/notice/view/46644?p=2"
          },
          {
              "seq": "3739",
              "title": "[학적] 2020-2학기 적용 부전공 승인자 발표",
              "author": "김희",
              "date": "2020-07-30",
              "url": "https://www.bible.ac.kr/ko/life/notice/view/46643?p=2"
          },
          {
              "seq": "3738",
              "title": "[학적] 2020-2학기 적용 복수전공 승인자 발표",
              "author": "김희",
              "date": "2020-07-30",
              "url": "https://www.bible.ac.kr/ko/life/notice/view/46641?p=2"
          },
          {
              "seq": "3737",
              "title": "[학적] 2020-2학기 적용 전과 승인자 발표",
              "author": "김희",
              "date": "2020-07-30",
              "url": "https://www.bible.ac.kr/ko/life/notice/view/46640?p=2"
          },
          {
              "seq": "3736",
              "title": "[수업] 2020-2학기 개설강좌 및 시간표 발표 안내",
              "author": "유다운",
              "date": "2020-07-28",
              "url": "https://www.bible.ac.kr/ko/life/notice/view/46633?p=2"
          },
          {
              "seq": "3735",
              "title": "[생활관] 2020-2학기 생활관 입주 신청 공고",
              "author": "조철남",
              "date": "2020-07-28",
              "url": "https://www.bible.ac.kr/ko/life/notice/view/46631?p=2"
          },
          {
              "seq": "3734",
              "title": "[학적] 2019학년도 후기 학위수여자 발표",
              "author": "김희",
              "date": "2020-07-24",
              "url": "https://www.bible.ac.kr/ko/life/notice/view/46617?p=2"
          },
          {
              "seq": "3733",
              "title": "[학점교류] 2020-2학기 서울여자대학교 학점교류 신청 안내",
              "author": "유다운",
              "date": "2020-07-24",
              "url": "https://www.bible.ac.kr/ko/life/notice/view/46616?p=2"
          },
          {
              "seq": "3732",
              "title": "[규정] 20-7월 규정 개정 공고",
              "author": "윤경민",
              "date": "2020-07-23",
              "url": "https://www.bible.ac.kr/ko/life/notice/view/46615?p=2"
          },
          {
              "seq": "3731",
              "title": "[수업] 2020-하계계절학기 성적 확인 및 이의신청 안내",
              "author": "유다운",
              "date": "2020-07-23",
              "url": "https://www.bible.ac.kr/ko/life/notice/view/46614?p=2"
          },
          {
              "seq": "3730",
              "title": "[대학인사] 2020년 장애대학생 교육복지지원 실태평가 위원회 및 보직변경에 따른 위원회 임명",
              "author": "김현동",
              "date": "2020-07-23",
              "url": "https://www.bible.ac.kr/ko/life/notice/view/46612?p=2"
          },
          {
              "seq": "3729",
              "title": "[수업] 2020-2학기 수강신청 안내 (수정 7/24)",
              "author": "유다운",
              "date": "2020-07-17",
              "url": "https://www.bible.ac.kr/ko/life/notice/view/46603?p=2"
          },
          {
              "seq": "3728",
              "title": "[채용] 컴퓨터소프트웨어학과 실습조교 채용 재공고(~7/24까지)",
              "author": "김병수",
              "date": "2020-07-17",
              "url": "https://www.bible.ac.kr/ko/life/notice/view/46601?p=2"
          },
          {
              "seq": "3727",
              "title": "[산학협력단] 2020년도 학술지지원사업(인문사회분야) 신규과제 공모",
              "author": "윤경민",
              "date": "2020-07-16",
              "url": "https://www.bible.ac.kr/ko/life/notice/view/46599?p=2"
          },
          {
              "seq": "3726",
              "title": "(코로나) 대학생 대면모임 및 활동 등 자제 협조 요청(교육부 공문)",
              "author": "김병수",
              "date": "2020-07-14",
              "url": "https://www.bible.ac.kr/ko/life/notice/view/46598?p=2"
          },
          {
              "seq": "3725",
              "title": "일립관 승강기(7층) 운행 중지 안내",
              "author": "이은광",
              "date": "2020-07-14",
              "url": "https://www.bible.ac.kr/ko/life/notice/view/46597?p=2"
          },
          {
              "seq": "3724",
              "title": "[채용] 컴퓨터소프트웨어학과 실습조교 채용 공고(~7/16까지)",
              "author": "김병수",
              "date": "2020-07-09",
              "url": "https://www.bible.ac.kr/ko/life/notice/view/46593?p=2"
          },
          {
              "seq": "3723",
              "title": "[수업] 2020-1학기 성적 이의신청 안내",
              "author": "유다운",
              "date": "2020-07-09",
              "url": "https://www.bible.ac.kr/ko/life/notice/view/46591?p=2"
          }
      ]
  }
  ```





  ```python
  import asyncio
  from pprint import pprint

  from biblebot import IntranetAPI


  async def main():
      account = ("본인 아이디", "본인 패스워드")

      
      resp = await IntranetAPI.Login.fetch(*account)
      result = IntranetAPI.Login.parse(resp)
      cookie = result.data["cookies"]

      
      resp = await IntranetAPI.Course.fetch(cookies=cookie, semester="20201")
      result = IntranetAPI.Course.parse(resp)
      pprint(result.data)

  asyncio.run(main())
  ```

  **Output:**

  ```json
  {
      "head": [
          "강좌코드",
          "강좌명",
          "이수구분",
          "학점",
          "교수명",
          "강의시간",
          "선택",
          "비고"
      ],
      "body": [
          [
              "GE264-A",
              "경건훈련",
              "기초공통필수",
              "0",
              "유정선",
              "(수)12:00~12:30",
              "",
              "NO"
          ],
          [
              "GE495-N",
              "전도훈련Ⅶ",
              "기초공통필수",
              "0",
              "최영태",
              "(수)13:30~15:20",
              "",
              "NO"
          ],
          [
              "GE748-A",
              "엑셀스프레드시트",
              "교양선택",
              "1",
              "한진호",
              "(월)14:55~16:10",
              "",
              "NO"
          ],
          [
              "IC122-A",
              "고급소프트웨어프로젝트",
              "전공선택",
              "3",
              "정해덕",
              "(화)14:55~16:10(목)14:55~16:10",
              "",
              "NO"
          ],
          [
              "IC134-D",
              "미래설계상담Ⅶ",
              "전공필수",
              "0",
              "정해덕",
              "(수)15:30~16:20",
              "",
              "NO"
          ],
          [
              "IC140-A",
              "빅데이터기술",
              "전공선택",
              "3",
              "양혜경",
              "(월)13:30~14:45(목)13:30~14:45",
              "",
              "NO"
          ],
          [
              "IC143-A",
              "종합설계I",
              "전공필수",
              "3",
              "정해덕",
              "(화)16:20~17:35(목)16:20~17:35",
              "",
              "NO"
          ],
          [
              "IC161-A",
              "창의적통합설계",
              "전공선택",
              "3",
              "현우석",
              "(월)16:20~17:35(화)13:30~14:45",
              "",
              "NO"
          ]
      ]
  }
  ```



  더 많은 기능은 [여기](docs/APIs.md)서 확인하세요.


pkgId: 664677083a7db66aa7c4123e3c44cc00b4d64b4422d9aa2f6a2a1f7be21fd082
name: python-bibleit
arch: src
version: 0.0.26
epoch: 0
release: 1
summary: Interactive bible reading
url: https://github.com/fmamud/bibleit
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibleit-0.0.26-1.src.rpm
checksum_type: sha256
description:
  Interactive Bible reading.



  ```
  $ python -m bibleit

  usage: bibleit [-h] [--version] [--repl] [--linesep value] [--bible value] [--debug] [--screen] [--textwrap] [--bold] [--label] [args ...]

  positional arguments:
    args             Arguments to be evaluated

  options:
    -h, --help       show this help message and exit
    --version        show program's version number and exit
    --repl           Opens bibleit REPL
    --linesep value  Configure line separator
    --bible value    Use one or more Bible translations
    --debug          Enable debug flag
    --screen         Enable screen flag
    --textwrap       Enable textwrap flag
    --bold           Enable bold flag
    --label          Enable label flag
  ```



  Bibleit has an interactive interpreter in order to interact with the Bible.

  You can use `--repl` argument:

  ```sh
  python -m bibleit --repl
  ```

  Or run directly from `bibleit.repl` module:

  ```sh
  python -m bibleit.repl
  ```

  After that you're going to see a console, so that you can start typing commands:

  ![](repl.gif)



  Contributions are very welcome! Check our [Contributing](CONTRIBUTING.md) guide.

rpm_license:
  MIT License  Copyright (c) 2022 Felipe Mamud  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: 347c127df231303cd58e636c9ec06b312df3d6ee211127cabd82f6b50afc3891
name: python-biblelib
arch: src
version: 0.3.17
epoch: 0
release: 1
summary: Utilities for working with metadata for Bible books, references, pericopes, and other units.
url: https://github.com/Clear-Bible/Biblelib/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biblelib-0.3.17-1.src.rpm
checksum_type: sha256
description:
  [![Release](https://img.shields.io/github/v/release/Clear-Bible/Biblelib)](https://img.shields.io/github/v/release/Clear-Bible/Biblelib)
  [![Build status](https://img.shields.io/github/workflow/status/sboisen/Biblelib/merge-to-main)](https://img.shields.io/github/workflow/status/sboisen/Biblelib/merge-to-main)
  [![codecov](https://codecov.io/gh/sboisen/Biblelib/branch/main/graph/badge.svg)](https://codecov.io/gh/sboisen/Biblelib)
  [![Commit activity](https://img.shields.io/github/commit-activity/m/sboisen/Biblelib)](https://img.shields.io/github/commit-activity/m/sboisen/Biblelib)
  [![Docs](https://img.shields.io/badge/docs-gh--pages-blue)](https://sboisen.github.io/Biblelib/)
  [![Code style with black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Imports with isort](https://img.shields.io/badge/%20imports-isort-%231674b1)](https://pycqa.github.io/isort/)
  [![License](https://img.shields.io/github/license/sboisen/Biblelib)](https://img.shields.io/github/license/sboisen/Biblelib)

  Utilities for working with Bible books, references, pericopes, and
  other units. Note this does _not_ include any actual Bible texts.

  - **Github repository**: <https://github.com/Clear-Bible/Biblelib
  - **Documentation** may *eventually* arrive at
    <https://clear-bible.github.io/Biblelib/> but can be found in the
    `docs` directory, and built using `mkdocs`.



  ```bash
  $ pip install biblelib
  ```


  * Book abbreviations incorporate public conventions developed by
      * [Unified Standard Format Markers
        3.0.0](https://ubsicap.github.io/usfm/index.html) (USFM), which
        is © Copyright 2018, United Bible Societies.
      * [The Open Scripture Information Standard
        (OSIS)](https://crosswire.org/osis/)
      * [Logos Bible Software](http://www.logos.com/)
  * Versification information included consulting sources from:
      * [The Copenhagen Alliance for Open Biblical Resources](http://copenhagen-alliance.org/)
      * [Paratext](https://paratext.org/)


pkgId: 529a73e3c04634a49b0e6ecc304b2d4737ecbdea1f490b51b3750c7ea23a7a4c
name: python-biblescrapeway
arch: src
version: 0.3.5
epoch: 0
release: 1
summary: A tool for scraping bible verses from the web
url: https://github.com/jonathanvanschenck/biblescrapeway
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biblescrapeway-0.3.5-1.src.rpm
checksum_type: sha256
description:
  A scraping tool for pulling bible verses from the web, [check it out here!](https://github.com/jonathanvanschenck/biblescrapeway)



  ```bash
   $ pip3 install biblescrapeway
  ```


  `biblescrapeway` comes with a simple cli (`bsw`) to pull specific bible passages:
  ```bash
   $ bsw John3.16
  ```

  You can also specify a translation (default is ESV):
  ```bash
   $ bsw --translation KJV John3.16
  ```

  Or, get multiple verses with comma delimiting:
  ```bash
   $ bsw John3.16,1Peter3:8
  ```

  Or, get a range of verses using a hyphon
  ```bash
   $ bsw John3.16-17
  ```

  You can specify a formatting type with the `--format/-f` option, which exposes raw json:
  ```bash
   $ bsw -f json John3.16
  ```

  You can also set the `--cache/--no-cache` flag to cache the results of queries locally, so
  that they can just be looked up on repeated evaluations. By default, `bsw` uses `--cache`.
  ```bash
   $ bsw --no-cache John3.16 # scraps the verse from the web
   $ bsw --no-cache John3.16 # scraps the verse from the web again
   $ bsw --cache John3.16    # scraps the verse, then saves it locally at '~/.bsw_cache.json'
   $ bsw --cache John3.16    # looks up the verse locally, does not re-scrape it
   $ bsw --no-cache John3.16 # scraps the verse from the web again
  ```


  It is also possible to get full verse objects via python, using the `query` function:
  ```python
  from biblescrapeway import query
  verse = query("John 3:16", version = "NIV")[0]
  verse.to_dict()
  ```
  The function returns a `scraper.Verse` object, which can be convered into a `dict` using
  the `.to_dict()` method. The resulting object has the following format:
  ```json
  {
      "book"    : "str | name of the bible book",
      "chapter" : "int | chapter number",
      "verse"   : "int | verse number",
      "version" : "str | bible version abbreviation",
      "text"    : "str | text content of the verse",
      "footnotes" : [
          {
              "str_index" : "int | index in text string of footnote location",
              "html"      : "str | html of footnote content"
          }
      ],
      "crossrefs" : [
          {
              "str_index" : "int  | index in text string of footnote location",
              "ref_list"  : "list | list of strings of cross referenced verses"
          }
      ]
  }
  ```

  The caching functionality is also accessible from the `query` function as:
  ```python
  verse_list = query("John3.16", cache=True) # scraps from the web
  verse_list = query("John3.16", cache=True) # just looks result up
  ```



  ```bash

  python3 -m venv venv
  ./venv/bin/pip install -r requirements.txt


  ./venv/bin/pip install --editable .


  ./scripts/run_tests.sh


  ./scripts/build.sh


  twine upload dist/*
  ```




   - Add more than just bgw as the scraping backend
   - More carefully handle formatting (unicode, text transforms, woj, etc).
   - Add WAY more documentations, like some docstrings for the modules . .
   - Add more unit tests
   - expand cli?
   - finish `string_cleaner` to convert special unicode characters into simpler characters
   - standardize some of the naming -- inconsisten use of `reference` to sometimes mean `Range`,
  also, `scrape` is pretty overloaded.
   - Descide how to handle 'Genesis 1:3-4:5,6', does that last one mean verse 6 or chapter 6?


pkgId: 6601f617932654da594a6bf6be63a7d9f4a4408eb17d044f404ecd7011d75429
name: python-bibli-ls
arch: src
version: 0.1.5.1
epoch: 0
release: 1
summary: A simple LSP server for your bibliographies
url: https://github.com/kha-dinh/bibli-ls
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibli-ls-0.1.5.1-1.src.rpm
checksum_type: sha256
description:
  <h3 align="center">
    <img
      src="https://raw.githubusercontent.com/kha-dinh/bibli-ls/main/docs/logo.jpeg"
      width="100"
      alt="Logo"
    /><br />
  </h3>



  A [Language Server](https://microsoft.github.io/language-server-protocol/) that brings bibliographies into your notes.

  [![image-version](https://img.shields.io/pypi/v/bibli-ls.svg)](https://python.org/pypi/bibli-ls)
  [![image-license](https://img.shields.io/pypi/l/bibli-ls.svg)](https://python.org/pypi/bibli-ls)
  [![image-python-versions](https://img.shields.io/badge/python->=3.8-blue)](https://python.org/pypi/bibli-ls)



  | LSP Features                                                                                                                                           | Behavior                                                                                                                 |
  | ------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------ |
  | [textDocument/definition](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_definition)         | Go to the first definition found in the `.bib` files.                                                                    |
  | [textDocument/references](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_references)         | Find appearance of `prefix + ID` with ripgrep.                                                                           |
  | [textDocument/hover](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_hover)                   | Show metadata from `.bib` files based on configurations.                                                                 |
  | [textDocument/completion](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_completion)         | Triggered by the `cite_prefix` configuration. Show completion of citation ID for bibtex entries and their documentation. |
  | [textDocument/diagnoistic](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_completion)        | Find citations without a proper entry in the bibfile.                                                                    |
  | [textDocument/implementation](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_implementation) | (Non-standard) Open `url` field of the citation in an external browser (TODO: make configurable).                        |



  Create a configuration file `.bibli.toml` at the root of your note directory. Here is a sample configuration:

  ```toml

  [backend]
  backend_type = "zotero_api" # Available backends: "bibfile", "zotero_api"

  [backend.bibfile]
  bibfiles = ["references.bib"]

  [backend.zotero_api]
  library_id = "5123456" # Your library ID
  library_type = "user" # "user"" or "group"
  api_key = "XXXXXXXXXXXXXXXXXXXXXXXX"

  [cite]
  prefix = "@" # e.g., "@john2024paper"

  [hover.doc_format]
  show_fields = ["abstract", "year", "booktitle", "url"]
  format = "table" # Available formats: "table"  and "list" (markdown)

  [completion.doc_format]
  show_fields = ["abstract", "year", "booktitle"]
  format = "list"

  ```



  Install the latest release of `bibli-ls` through `pip`:

  ```bash
  pip install bibli-ls


  pipx install bibli-ls
  ```



  Automatic configuration through [lspconfig]() has yet to be supported. To enable bibli-ls, put the following code in your Neovim config.

  ```lua
  local lspconfig = require("lspconfig")
  local configs = require("lspconfig.configs")

  if not configs.bibli_ls then
    configs.bibli_ls = {
      default_config = {
        cmd = { "bibli_ls" },
        filetypes = { "markdown" },
        root_dir = lspconfig.util.root_pattern(".bibli.toml"),
        -- Optional: visit the URL of the citation with LSP DocumentImplementation
        on_attach = function(client, bufnr)
          vim.keymap.set({ "n" }, "<cr>", function()
            vim.lsp.buf.implementation()
          end)
        end,
      },
    }
  end

  lspconfig.bibli_ls.setup({})
  ```



  Currently, Bibli supports `bibfile` and `zotero_api` backends.

  `bibfile` backend loads the library from a local bibtex file.

  `zotero_api` backend connects directly to your Zotero web library, removing the need for maintaining separated bibfile.

  - [More on setting up citation keys](/docs/custom-cite-keys.md)



  From the root directory:

  ```bash
  pyproject-build
  pip install dist/bibli_ls-{version}-py3-none-any.whl # --force-reinstall if needed

  pipx install . # --force-reinstall if needed


  ```


pkgId: b1acd94fc956c8b926f6e6131f64d1e83dcdd8b7b0499769a0fb06b5b9300d37
name: python-bibli-ls
arch: src
version: 0.1.5.2
epoch: 0
release: 1
summary: A simple LSP server for your bibliographies
url: https://github.com/kha-dinh/bibli-ls
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibli-ls-0.1.5.2-1.src.rpm
checksum_type: sha256
description:
  <h3 align="center">
    <img
      src="https://raw.githubusercontent.com/kha-dinh/bibli-ls/main/docs/logo.jpeg"
      width="100"
      alt="Logo"
    /><br />
  </h3>



  A [Language Server](https://microsoft.github.io/language-server-protocol/) that brings bibliographies into your notes.

  [![image-version](https://img.shields.io/pypi/v/bibli-ls.svg)](https://python.org/pypi/bibli-ls)
  [![image-license](https://img.shields.io/pypi/l/bibli-ls.svg)](https://python.org/pypi/bibli-ls)
  [![image-python-versions](https://img.shields.io/badge/python->=3.8-blue)](https://python.org/pypi/bibli-ls)



  | LSP Features                                                                                                                                           | Behavior                                                                                                                 |
  | ------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------ |
  | [textDocument/definition](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_definition)         | Go to the first definition found in the `.bib` files.                                                                    |
  | [textDocument/references](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_references)         | Find appearance of `prefix + ID` with ripgrep.                                                                           |
  | [textDocument/hover](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_hover)                   | Show metadata from `.bib` files based on configurations.                                                                 |
  | [textDocument/completion](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_completion)         | Triggered by the `cite_prefix` configuration. Show completion of citation ID for bibtex entries and their documentation. |
  | [textDocument/diagnoistic](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_completion)        | Find citations without a proper entry in the bibfile.                                                                    |
  | [textDocument/implementation](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_implementation) | (Non-standard) Open `url` field of the citation in an external browser (TODO: make configurable).                        |



  Create a configuration file `.bibli.toml` at the root of your note directory. Here is a sample configuration:

  ```toml

  [backend]

  [backend.mylib]
  backend_type = "bibfile" # Available backends: "bibfile", "zotero_api"
  bibfiles = ["references.bib"]

  [backend.my_lab_lib]
  backend_type = "zotero_api"
  library_id = "5123456" # Your library ID
  library_type = "user" # "user"" or "group"
  api_key = "XXXXXXXXXXXXXXXXXXXXXXXX"

  [cite]
  prefix = "@" # e.g., "@john2024paper"

  [hover.doc_format]
  show_fields = ["abstract", "year", "booktitle", "url"]
  format = "table" # Available formats: "table"  and "list" (markdown)

  [completion.doc_format]
  show_fields = ["abstract", "year", "booktitle"]
  format = "list"

  ```



  Install the latest release of `bibli-ls` through `pip`:

  ```bash
  pip install bibli-ls


  pipx install bibli-ls
  ```



  Automatic configuration through [lspconfig]() has yet to be supported. To enable bibli-ls, put the following code in your Neovim config.

  ```lua
  local lspconfig = require("lspconfig")
  local configs = require("lspconfig.configs")

  if not configs.bibli_ls then
    configs.bibli_ls = {
      default_config = {
        cmd = { "bibli_ls" },
        filetypes = { "markdown" },
        root_dir = lspconfig.util.root_pattern(".bibli.toml"),
        -- Optional: visit the URL of the citation with LSP DocumentImplementation
        on_attach = function(client, bufnr)
          vim.keymap.set({ "n" }, "<cr>", function()
            vim.lsp.buf.implementation()
          end)
        end,
      },
    }
  end

  lspconfig.bibli_ls.setup({})
  ```



  Currently, Bibli supports `bibfile` and `zotero_api` backends.

  `bibfile` backend loads the library from a local bibtex file.

  `zotero_api` backend connects directly to your Zotero web library, removing the need for maintaining separated bibfiles.

  - [More on setting up citation keys](/docs/custom-cite-keys.md)



  From the root directory:

  ```bash
  pyproject-build
  pip install dist/bibli_ls-{version}-py3-none-any.whl # --force-reinstall if needed

  pipx install . # --force-reinstall if needed


  ```


pkgId: c616b3407f8b3db72ec242cf38d52263c74f9d01aaf291cd158331728ec8e95f
name: python-bibli-ls
arch: src
version: 0.1.6.1
epoch: 0
release: 1
summary: A simple LSP server for your bibliographies
url: https://github.com/kha-dinh/bibli-ls
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibli-ls-0.1.6.1-1.src.rpm
checksum_type: sha256
description:
  <h3 align="center">
    <img
      src="https://raw.githubusercontent.com/kha-dinh/bibli-ls/main/docs/logo.jpeg"
      width="100"
      alt="Logo"
    /><br />
  </h3>



  A [Language Server](https://microsoft.github.io/language-server-protocol/) that brings bibliographies into your notes.

  [![image-version](https://img.shields.io/pypi/v/bibli-ls.svg)](https://python.org/pypi/bibli-ls)
  [![image-license](https://img.shields.io/pypi/l/bibli-ls.svg)](https://python.org/pypi/bibli-ls)
  [![image-python-versions](https://img.shields.io/badge/python->=3.8-blue)](https://python.org/pypi/bibli-ls)



  | LSP Features                                                                                                                                           | Behavior                                                                                                                 |
  | ------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------ |
  | [textDocument/definition](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_definition)         | Go to the first definition found in the `.bib` files.                                                                    |
  | [textDocument/references](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_references)         | Find appearance of `prefix + ID` with ripgrep.                                                                           |
  | [textDocument/hover](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_hover)                   | Show metadata from `.bib` files based on configurations.                                                                 |
  | [textDocument/completion](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_completion)         | Triggered by the `cite_prefix` configuration. Show completion of citation ID for bibtex entries and their documentation. |
  | [textDocument/diagnoistic](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_completion)        | Find citations without a proper entry in the bibfile.                                                                    |
  | [textDocument/implementation](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_implementation) | (Non-standard) Open `url` field of the citation in an external browser (TODO: make configurable).                        |



  Create a configuration file `.bibli.toml` at the root of your note directory. Here is a sample configuration. For the complete list of configurations, refer to the [documentation](/docs/configurations.md) and the [default config](/docs/default-config.toml).

  ```toml

  [backends]

  [backends.mylib]
  backend_type = "bibfile" # Available backends: "bibfile", "zotero_api"
  bibfiles = ["references.bib"]

  [backends.my_lab_lib]
  backend_type = "zotero_api"
  library_id = "5123456" # Your library ID
  library_type = "user" # "user"" or "group"
  api_key = "XXXXXXXXXXXXXXXXXXXXXXXX"

  [cite]
  prefix = "@" # e.g., "@john2024paper"

  [hover.doc_format]
  show_fields = ["abstract", "year", "booktitle", "url"]
  format = "table" # Available formats: "table"  and "list" (markdown)

  [completion.doc_format]
  show_fields = ["abstract", "year", "booktitle"]
  format = "list"

  ```



  Install the latest release of `bibli-ls` through `pip`:

  ```bash
  pip install bibli-ls


  pipx install bibli-ls
  ```



  Automatic configuration through [lspconfig]() has yet to be supported. To enable bibli-ls, put the following code in your Neovim config.

  ```lua
  local lspconfig = require("lspconfig")
  local configs = require("lspconfig.configs")

  if not configs.bibli_ls then
    configs.bibli_ls = {
      default_config = {
        cmd = { "bibli_ls" },
        filetypes = { "markdown" },
        root_dir = lspconfig.util.root_pattern(".bibli.toml"),
        -- Optional: visit the URL of the citation with LSP DocumentImplementation
        on_attach = function(client, bufnr)
          vim.keymap.set({ "n" }, "<cr>", function()
            vim.lsp.buf.implementation()
          end)
        end,
      },
    }
  end

  lspconfig.bibli_ls.setup({})
  ```



  Currently, Bibli supports `bibfile` and `zotero_api` backends.

  - `bibfile` backend loads the library from a local bibtex file.

  - `zotero_api` backend connects directly to your Zotero web library, removing the need for maintaining separated bibfiles. It cache the results in a bibfile named `.{backend name}_{library type}_{library id}.bib`. Run the command LSP `library.reload_all` to refetch the online content.

    - [More on setting up citation keys for online libraries](/docs/custom-cite-keys.md)



  From the root directory:

  ```bash
  pip install . # --force-reinstall if needed

  pipx install . # --force-reinstall if needed


  ```


pkgId: aa6fc823842322f7350208c8ec928c1dd199a2ee8935d0192a2701c8c0bf5dfa
name: python-bibmancli
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: Simple CLI tool to manage BibTeX files.
url: https://github.com/Parzival1918/bibman
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibmancli-0.3.4-1.src.rpm
checksum_type: sha256
description:
  <center>

  [![Rye](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/rye/main/artwork/badge.json)](https://rye.astral.sh)
  ![GitHub License](https://img.shields.io/github/license/parzival1918/bibman)

  ![PyPI - Version](https://img.shields.io/pypi/v/bibmancli)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/bibmancli)

  </center>

  A CLI utility to manage references in BibTeX format. See the [documentation](https://parzival1918.github.io/bibman/) for more information.

  Check my references managed using this tool and hosted in GitHub Pages [here](https://parzival1918.github.io/references/).



  I would recommend using [`pipx`](https://github.com/pypa/pipx) to install `bibman`:

  ```bash
  > pipx install bibmancli
  ```

  Alternatively, you can install it using `pip`:

  ```bash
  > pip install bibmancli
  ```

  This repository also includes a Nix Flake to install the application. You can use it by adding to your Flake inputs:

  ```nix
  inputs.bibman.url = "github:parzival1918/bibman/51a05e0ea3388617f87d19bb0aaee01e30726df6";
  ```

  and the following to your system or user packages:

  ```nix
  [
      (...)
      inputs.bibman.packages.${systemArch}.bibman
      (...)
  ];
  ```

  This will install the `bibman` CLI.

  **Warning**: The package uses a pre-release version of `bibtexparser`. This may cause issues with the installation (e.g. I can't install it using rye).

  **Warning**: The `pip` installation method is not recommended as it may cause conflicts with other packages. `pipx` creates a virtual environment for the package and installs it there to avoid conflicts.

  **Warning**: The CLI is still in development and may have bugs. Please report any issues you encounter.


pkgId: 1a05f9450ace8931446d567d732efdd9714de6964a921c5ec72085d1066e9b74
name: python-bibo
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: Command line reference manager with single source of truth: the .bib file. Inspired by beets
url: https://github.com/Nagasaki45/bibo
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibo-0.1.9-1.src.rpm
checksum_type: sha256
description:
  * Documentation: https://bibo.readthedocs.io/en/latest
  * Source code: https://github.com/Nagasaki45/bibo
  * PyPI releases: https://pypi.org/project/bibo
  * License: `MIT`_


pkgId: b302626453567971501b7aa1c2887fbab71a23fab9212c0cb5215cba40704913
name: python-bibt-gcp-asset
arch: src
version: 0.1.43
epoch: 0
release: 1
summary: Functionality often used by BITS Blue Team (GCP Asset Module).
url: https://github.com/broadinstitute/bibt-gcp-asset
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibt-gcp-asset-0.1.43-1.src.rpm
checksum_type: sha256
description:
  - **Developer**: Matthew OBrien
  - **Email**: mobrien@broadinstitute.org
  - **Project URL**: https://pypi.org/project/bibt-gcp-asset/
  - **Project Repo**: https://github.com/broadinstitute/bibt-gcp-asset
  - **Project Documentation**: https://bibt-gcp-asset.readthedocs.io/en/latest/



  ```bash
  $ pip install --upgrade bibt-gcp-asset
  ```



  - See documentation here: https://bibt-gcp-asset.readthedocs.io/en/latest/



  - [bibt-gcp-asset](https://github.com/broadinstitute/bibt-gcp-asset)
  - [bibt-gcp-bq](https://github.com/broadinstitute/bibt-gcp-bq)
  - [bibt-gcp-iam](https://github.com/broadinstitute/bibt-gcp-iam)
  - [bibt-gcp-pubsub](https://github.com/broadinstitute/bibt-gcp-pubsub)
  - [bibt-gcp-scc](https://github.com/broadinstitute/bibt-gcp-scc)
  - [bibt-gcp-secrets](https://github.com/broadinstitute/bibt-gcp-secrets)
  - [bibt-gcp-storage](https://github.com/broadinstitute/bibt-gcp-storage)
  - [bibt-qualys](https://github.com/broadinstitute/bibt-qualys)
  - [bibt-sentinelone](https://github.com/broadinstitute/bibt-sentinelone)
  - [bibt-slack](https://github.com/broadinstitute/bibt-slack)


pkgId: 42224b9bd8bc8a4c951187d81a468ffb2eb33af380293dab231f98ea11acf1a4
name: python-bibt-gcp-bq
arch: src
version: 0.0.24
epoch: 0
release: 1
summary: Functionality often used by BITS Blue Team (GCP BigQuery Module).
url: https://github.com/broadinstitute/bibt-gcp-bq
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibt-gcp-bq-0.0.24-1.src.rpm
checksum_type: sha256
description:
  - **Developer**: Matthew OBrien
  - **Email**: mobrien@broadinstitute.org
  - **Project URL**: https://pypi.org/project/bibt-gcp-bq/
  - **Project Repo**: https://github.com/broadinstitute/bibt-gcp-bq
  - **Project Documentation**: https://bibt-gcp-bq.readthedocs.io/en/latest/



  ```bash
  $ pip install --upgrade bibt-gcp-bq
  ```



  - See documentation here: https://bibt-gcp-bq.readthedocs.io/en/latest/



  - [bibt-gcp-asset](https://github.com/broadinstitute/bibt-gcp-asset)
  - [bibt-gcp-bq](https://github.com/broadinstitute/bibt-gcp-bq)
  - [bibt-gcp-iam](https://github.com/broadinstitute/bibt-gcp-iam)
  - [bibt-gcp-pubsub](https://github.com/broadinstitute/bibt-gcp-pubsub)
  - [bibt-gcp-scc](https://github.com/broadinstitute/bibt-gcp-scc)
  - [bibt-gcp-secrets](https://github.com/broadinstitute/bibt-gcp-secrets)
  - [bibt-gcp-storage](https://github.com/broadinstitute/bibt-gcp-storage)
  - [bibt-qualys](https://github.com/broadinstitute/bibt-qualys)
  - [bibt-sentinelone](https://github.com/broadinstitute/bibt-sentinelone)
  - [bibt-slack](https://github.com/broadinstitute/bibt-slack)


pkgId: 891fdba8eff0ef1f45c6809fb0a7787e0d60402679fe06c43a2d187d249816a6
name: python-bibt-gcp-iam
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Functionality often used by BITS Blue Team (IAM Module).
url: https://github.com/broadinstitute/bibt-gcp-iam
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibt-gcp-iam-0.1.4-1.src.rpm
checksum_type: sha256
description:
  - **Developer**: Matthew OBrien
  - **Email**: mobrien@broadinstitute.org
  - **Project URL**: https://pypi.org/project/bibt-gcp-iam/
  - **Project Repo**: https://github.com/broadinstitute/bibt-gcp-iam
  - **Project Documentation**: https://bibt-gcp-iam.readthedocs.io/en/latest/



  ```bash
  $ pip install --upgrade bibt-gcp-iam
  ```



  - See documentation here: https://bibt-gcp-iam.readthedocs.io/en/latest/



  - [bibt-gcp-asset](https://github.com/broadinstitute/bibt-gcp-asset)
  - [bibt-gcp-bq](https://github.com/broadinstitute/bibt-gcp-bq)
  - [bibt-gcp-iam](https://github.com/broadinstitute/bibt-gcp-iam)
  - [bibt-gcp-pubsub](https://github.com/broadinstitute/bibt-gcp-pubsub)
  - [bibt-gcp-scc](https://github.com/broadinstitute/bibt-gcp-scc)
  - [bibt-gcp-secrets](https://github.com/broadinstitute/bibt-gcp-secrets)
  - [bibt-gcp-storage](https://github.com/broadinstitute/bibt-gcp-storage)
  - [bibt-qualys](https://github.com/broadinstitute/bibt-qualys)
  - [bibt-sentinelone](https://github.com/broadinstitute/bibt-sentinelone)
  - [bibt-slack](https://github.com/broadinstitute/bibt-slack)


pkgId: b8f6a1031fa5aacf0ada896294e2825dd29c78f7471e56707f231d14547e0988
name: python-bibt-gcp-pubsub
arch: src
version: 0.0.20
epoch: 0
release: 1
summary: Functionality often used by BITS Blue Team (PubSub module).
url: https://github.com/broadinstitute/bibt-gcp-pubsub
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibt-gcp-pubsub-0.0.20-1.src.rpm
checksum_type: sha256
description:
  - **Developer**: Matthew OBrien
  - **Email**: mobrien@broadinstitute.org
  - **Project URL**: https://pypi.org/project/bibt-gcp-pubsub/
  - **Project Repo**: https://github.com/broadinstitute/bibt-gcp-pubsub
  - **Project Documentation**: https://bibt-gcp-pubsub.readthedocs.io/en/latest/



  ```bash
  $ pip install --upgrade bibt-gcp-pubsub
  ```



  - See documentation here: https://bibt-gcp-pubsub.readthedocs.io/en/latest/



  - [bibt-gcp-asset](https://github.com/broadinstitute/bibt-gcp-asset)
  - [bibt-gcp-bq](https://github.com/broadinstitute/bibt-gcp-bq)
  - [bibt-gcp-iam](https://github.com/broadinstitute/bibt-gcp-iam)
  - [bibt-gcp-pubsub](https://github.com/broadinstitute/bibt-gcp-pubsub)
  - [bibt-gcp-scc](https://github.com/broadinstitute/bibt-gcp-scc)
  - [bibt-gcp-secrets](https://github.com/broadinstitute/bibt-gcp-secrets)
  - [bibt-gcp-storage](https://github.com/broadinstitute/bibt-gcp-storage)
  - [bibt-qualys](https://github.com/broadinstitute/bibt-qualys)
  - [bibt-sentinelone](https://github.com/broadinstitute/bibt-sentinelone)
  - [bibt-slack](https://github.com/broadinstitute/bibt-slack)


pkgId: 329bce0a1504ed963a06bbd6ce642964d50460c2365e3d804020439b95606ccc
name: python-bibt-gcp-scc
arch: src
version: 1.1.10
epoch: 0
release: 1
summary: Functionality often used by BITS Blue Team (GCP SCC Module).
url: https://github.com/broadinstitute/bibt-gcp-scc
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibt-gcp-scc-1.1.10-1.src.rpm
checksum_type: sha256
description:
  - **Developer**: Matthew OBrien
  - **Email**: mobrien@broadinstitute.org
  - **Project URL**: https://pypi.org/project/bibt-gcp-scc/
  - **Project Repo**: https://github.com/broadinstitute/bibt-gcp-scc
  - **Project Documentation**: https://bibt-gcp-scc.readthedocs.io/en/latest/



  ```bash
  $ pip install --upgrade bibt-gcp-scc
  ```



  - Requires Docker to be installed on your system.
  - Clone this repo and create & run the test container:

  ```
  $ docker build -f ./Dockerfile -t bibt-gcp-scc-test . && docker run bibt-gcp-scc-test
  ```



  - See documentation here: https://bibt-gcp-scc.readthedocs.io/en/latest/



  - [bibt-gcp-asset](https://github.com/broadinstitute/bibt-gcp-asset)
  - [bibt-gcp-bq](https://github.com/broadinstitute/bibt-gcp-bq)
  - [bibt-gcp-iam](https://github.com/broadinstitute/bibt-gcp-iam)
  - [bibt-gcp-pubsub](https://github.com/broadinstitute/bibt-gcp-pubsub)
  - [bibt-gcp-scc](https://github.com/broadinstitute/bibt-gcp-scc)
  - [bibt-gcp-secrets](https://github.com/broadinstitute/bibt-gcp-secrets)
  - [bibt-gcp-storage](https://github.com/broadinstitute/bibt-gcp-storage)
  - [bibt-qualys](https://github.com/broadinstitute/bibt-qualys)
  - [bibt-sentinelone](https://github.com/broadinstitute/bibt-sentinelone)
  - [bibt-slack](https://github.com/broadinstitute/bibt-slack)


pkgId: 015114c371673d1825bc2895c609ea8bb75f57f89698cefa5fb95046cee35339
name: python-bibt-gcp-secrets
arch: src
version: 0.0.13
epoch: 0
release: 1
summary: Functionality often used by BITS Blue Team (GCP Secret Manager).
url: https://github.com/broadinstitute/bibt-gcp-secrets
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibt-gcp-secrets-0.0.13-1.src.rpm
checksum_type: sha256
description:
  - **Developer**: Matthew OBrien
  - **Email**: mobrien@broadinstitute.org
  - **Project URL**: https://pypi.org/project/bibt-gcp-secrets/
  - **Project Repo**: https://github.com/broadinstitute/bibt-gcp-secrets
  - **Project Documentation**: https://bibt-gcp-secrets.readthedocs.io/en/latest/



  ```bash
  $ pip install --upgrade bibt-gcp-secrets
  ```



  - See documentation here: https://bibt-gcp-secrets.readthedocs.io/en/latest/



  - [bibt-gcp-asset](https://github.com/broadinstitute/bibt-gcp-asset)
  - [bibt-gcp-bq](https://github.com/broadinstitute/bibt-gcp-bq)
  - [bibt-gcp-iam](https://github.com/broadinstitute/bibt-gcp-iam)
  - [bibt-gcp-pubsub](https://github.com/broadinstitute/bibt-gcp-pubsub)
  - [bibt-gcp-scc](https://github.com/broadinstitute/bibt-gcp-scc)
  - [bibt-gcp-secrets](https://github.com/broadinstitute/bibt-gcp-secrets)
  - [bibt-gcp-storage](https://github.com/broadinstitute/bibt-gcp-storage)
  - [bibt-qualys](https://github.com/broadinstitute/bibt-qualys)
  - [bibt-sentinelone](https://github.com/broadinstitute/bibt-sentinelone)
  - [bibt-slack](https://github.com/broadinstitute/bibt-slack)


pkgId: 27b17fed7d3d82c2453b890611884ae9cc36330cb136879c5b0cce473c0b3e53
name: python-bibt-gcp-storage
arch: src
version: 0.0.13
epoch: 0
release: 1
summary: Functionality often used by BITS Blue Team (GCP GCS).
url: https://github.com/broadinstitute/bibt-gcp-storage
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibt-gcp-storage-0.0.13-1.src.rpm
checksum_type: sha256
description:
  - **Developer**: Matthew OBrien
  - **Email**: mobrien@broadinstitute.org
  - **Project URL**: https://pypi.org/project/bibt-gcp-storage/
  - **Project Repo**: https://github.com/broadinstitute/bibt-gcp-storage
  - **Project Documentation**: https://bibt-gcp-storage.readthedocs.io/en/latest/



  ```bash
  $ pip install --upgrade bibt-gcp-storage
  ```



  - See documentation here: https://bibt-gcp-storage.readthedocs.io/en/latest/



  - [bibt-gcp-asset](https://github.com/broadinstitute/bibt-gcp-asset)
  - [bibt-gcp-bq](https://github.com/broadinstitute/bibt-gcp-bq)
  - [bibt-gcp-iam](https://github.com/broadinstitute/bibt-gcp-iam)
  - [bibt-gcp-pubsub](https://github.com/broadinstitute/bibt-gcp-pubsub)
  - [bibt-gcp-scc](https://github.com/broadinstitute/bibt-gcp-scc)
  - [bibt-gcp-secrets](https://github.com/broadinstitute/bibt-gcp-secrets)
  - [bibt-gcp-storage](https://github.com/broadinstitute/bibt-gcp-storage)
  - [bibt-qualys](https://github.com/broadinstitute/bibt-qualys)
  - [bibt-sentinelone](https://github.com/broadinstitute/bibt-sentinelone)
  - [bibt-slack](https://github.com/broadinstitute/bibt-slack)


pkgId: 27e894db8375bb9a6542ee41cbdfb7ba009ceea1c00ed818ddbdafd28aed1a64
name: python-bibt-qualys
arch: src
version: 0.0.27
epoch: 0
release: 1
summary: Functionality often used by BITS Blue Team (Qualys).
url: https://github.com/broadinstitute/bibt-qualys
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibt-qualys-0.0.27-1.src.rpm
checksum_type: sha256
description:
  - **Developer**: Matthew OBrien
  - **Email**: mobrien@broadinstitute.org
  - **Project URL**: https://pypi.org/project/bibt-qualys/
  - **Project Repo**: https://github.com/broadinstitute/bibt-qualys
  - **Project Documentation**: https://bibt-qualys.readthedocs.io/en/latest/



  ```bash
  $ pip install --upgrade bibt-qualys
  ```



  - See documentation here: https://bibt-qualys.readthedocs.io/en/latest/



  - [bibt-gcp-asset](https://github.com/broadinstitute/bibt-gcp-asset)
  - [bibt-gcp-bq](https://github.com/broadinstitute/bibt-gcp-bq)
  - [bibt-gcp-iam](https://github.com/broadinstitute/bibt-gcp-iam)
  - [bibt-gcp-pubsub](https://github.com/broadinstitute/bibt-gcp-pubsub)
  - [bibt-gcp-scc](https://github.com/broadinstitute/bibt-gcp-scc)
  - [bibt-gcp-secrets](https://github.com/broadinstitute/bibt-gcp-secrets)
  - [bibt-gcp-storage](https://github.com/broadinstitute/bibt-gcp-storage)
  - [bibt-qualys](https://github.com/broadinstitute/bibt-qualys)
  - [bibt-sentinelone](https://github.com/broadinstitute/bibt-sentinelone)
  - [bibt-slack](https://github.com/broadinstitute/bibt-slack)


pkgId: 165ee93715adf48a4fb758ea4741771ebb55dee88c21db8bc73502bbd1faf43c
name: python-bibt-sentinelone
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: Functionality often used by BITS Blue Team (SentinelOne).
url: https://github.com/broadinstitute/bibt-sentinelone
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibt-sentinelone-0.0.5-1.src.rpm
checksum_type: sha256
description:
  - **Developer**: Matthew OBrien
  - **Email**: mobrien@broadinstitute.org
  - **Project URL**: https://pypi.org/project/bibt-sentinelone/
  - **Project Repo**: https://github.com/broadinstitute/bibt-sentinelone
  - **Project Documentation**: https://bibt-sentinelone.readthedocs.io/en/latest/



  ```bash
  $ pip install --upgrade bibt-sentinelone
  ```



  - See documentation here: https://bibt-sentinelone.readthedocs.io/en/latest/



  - [bibt-gcp-asset](https://github.com/broadinstitute/bibt-gcp-asset)
  - [bibt-gcp-bq](https://github.com/broadinstitute/bibt-gcp-bq)
  - [bibt-gcp-iam](https://github.com/broadinstitute/bibt-gcp-iam)
  - [bibt-gcp-pubsub](https://github.com/broadinstitute/bibt-gcp-pubsub)
  - [bibt-gcp-scc](https://github.com/broadinstitute/bibt-gcp-scc)
  - [bibt-gcp-secrets](https://github.com/broadinstitute/bibt-gcp-secrets)
  - [bibt-gcp-storage](https://github.com/broadinstitute/bibt-gcp-storage)
  - [bibt-qualys](https://github.com/broadinstitute/bibt-qualys)
  - [bibt-sentinelone](https://github.com/broadinstitute/bibt-sentinelone)
  - [bibt-slack](https://github.com/broadinstitute/bibt-slack)


pkgId: deb893caf3485517062597e6abdaf693e54f101b8a10fd1d52385382b841cd28
name: python-bibt-slack
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: Functionality often used by BITS Blue Team (Slack).
url: https://github.com/broadinstitute/bibt-slack
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibt-slack-0.1.3-1.src.rpm
checksum_type: sha256
description:
  - **Developer**: Matthew OBrien
  - **Email**: mobrien@broadinstitute.org
  - **Project URL**: https://pypi.org/project/bibt-slack/
  - **Project Repo**: https://github.com/broadinstitute/bibt-slack
  - **Project Documentation**: https://bibt-slack.readthedocs.io/en/latest/



  ```bash
  $ pip install --upgrade bibt-slack
  ```



  - See documentation here: https://bibt-slack.readthedocs.io/en/latest/
  - For more complicated Slack workflows, consider using [Slack Bolt](https://slack.dev/bolt-python/api-docs/slack_bolt/).



  - [bibt-gcp-asset](https://github.com/broadinstitute/bibt-gcp-asset)
  - [bibt-gcp-bq](https://github.com/broadinstitute/bibt-gcp-bq)
  - [bibt-gcp-iam](https://github.com/broadinstitute/bibt-gcp-iam)
  - [bibt-gcp-pubsub](https://github.com/broadinstitute/bibt-gcp-pubsub)
  - [bibt-gcp-scc](https://github.com/broadinstitute/bibt-gcp-scc)
  - [bibt-gcp-secrets](https://github.com/broadinstitute/bibt-gcp-secrets)
  - [bibt-gcp-storage](https://github.com/broadinstitute/bibt-gcp-storage)
  - [bibt-qualys](https://github.com/broadinstitute/bibt-qualys)
  - [bibt-sentinelone](https://github.com/broadinstitute/bibt-sentinelone)
  - [bibt-slack](https://github.com/broadinstitute/bibt-slack)


pkgId: a4a326c15fbb3c5b268d0fa432789ad14aefbceaa7483807e9ecfecce7be70d3
name: python-bibtexautocomplete
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Script to autocomplete bibtex files by polling online databases
url: https://github.com/dlesbre/bibtex-autocomplete
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibtexautocomplete-1.4.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version][version-shield]][pypi-link]
  [![PyPI pyversions][pyversion-shield]][pypi-link]
  [![License][license-shield]](https://choosealicense.com/licenses/mit/)
  [![PyPI status][status-shield]][pypi-link]
  [![Downloads][download-shield]](https://pepy.tech/project/bibtexautocomplete)

  [![Maintenance][maintain-shield]][commit-link]
  [![Commit][commit-shield]][commit-link]
  [![actions][pipeline-shield]][pipeline-link]
  [![issues][issues-shield]][issues-link]
  [![pull requests][pr-shield]][pr-link]

  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.10207744.svg)](https://doi.org/10.5281/zenodo.10207744)

  [version-shield]:   https://img.shields.io/pypi/v/bibtexautocomplete.svg
  [pyversion-shield]: https://img.shields.io/pypi/pyversions/bibtexautocomplete.svg
  [license-shield]:   https://img.shields.io/pypi/l/bibtexautocomplete.svg
  [status-shield]:    https://img.shields.io/pypi/status/bibtexautocomplete.svg
  [download-shield]:  https://static.pepy.tech/badge/bibtexautocomplete
  [pypi-link]: https://pypi.python.org/pypi/bibtexautocomplete/

  [maintain-shield]: https://img.shields.io/badge/Maintained%3F-yes-brightgreen.svg
  [commit-shield]: https://img.shields.io/github/last-commit/dlesbre/bibtex-autocomplete
  [commit-link]: https://github.com/dlesbre/bibtex-autocomplete/graphs/commit-activity

  [pipeline-shield]: https://img.shields.io/github/actions/workflow/status/dlesbre/bibtex-autocomplete/python-app.yml?branch=master&label=tests
  [pipeline-link]: https://github.com/dlesbre/bibtex-autocomplete/actions/workflows/python-app.yml

  [issues-shield]: https://img.shields.io/github/issues/dlesbre/bibtex-autocomplete
  [issues-link]: https://github.com/dlesbre/bibtex-autocomplete/issues

  [pr-shield]: https://img.shields.io/github/issues-pr/dlesbre/bibtex-autocomplete
  [pr-link]: https://github.com/dlesbre/bibtex-autocomplete/pulls

  **bibtex-autocomplete** or **btac** is a simple script to autocomplete BibTeX
  bibliographies. It reads a BibTeX file and looks online for any additional data
  to add to each entry. It can quickly generate entries from minimal data (a lone
  title is often sufficient to generate a full entry). You can also use it to only
  add specific fields (like DOIs, or ISSN) to a manually curated bib file.

  It is designed to be as simple to use as possible: just give it a bib file and
  let **btac** work its magic! It combines multiple sources and runs consistency
  and normalization checks on the added fields (check that URLs lead to a valid
  webpage, that DOIs exist at https://dx.doi.org/).

  It attempts to complete a BibTeX file by querying the following domains:
  - [openalex.org](https://openalex.org/): ~240 million entries
  - [www.crossref.org](https://www.crossref.org/): ~150 million entries
  - [arxiv.org](https://arxiv.org/): open access archive, ~2.4 million entries
  - [semanticscholar.org](https://www.semanticscholar.org/): ~215 million entries
  - [unpaywall.org](https://unpaywall.org/): database of open access articles, ~48 million entries
  - [dblp.org](https://dblp.org): computer science, ~7 million entries
  - [researchr.org](https://researchr.org/): computer science
  - [inspirehep.net](https://inspirehep.net/): high-energy physics, ~1.5 million entries

  Big thanks to all of them for allowing open, easy and well-documented access to
  their databases. This project wouldn't be possible without them. You can easily
  narrow down the list of sources if some aren't relevant using [command line options](#query-filtering).



  - [New in version 1.3](#new-in-version-13)
  - [Demo](#demo)
  - [Quick overview](#quick-overview)
  - [Installation](#installation)
    - [Shell tab completion](#shell-tab-completion)
    - [Dependencies](#dependencies)
  - [Usage](#usage)
  - [Command line arguments](#command-line-arguments)
    - [Specifying output](#specifying-output)
    - [Query filtering](#query-filtering)
    - [New field formatting](#new-field-formatting)
    - [Global output formatting](#global-output-formatting)
    - [Optional flags](#optional-flags)
  - [Running from python](#running-from-python)
  - [Credit and license](#credit-and-license)



  Added OpenAlex and Inspire HEP as sources. Switched to a majority vote between source
  to find new field, along with smart field normalization and comparison. And of course,
  bug fixes!

  See the [changelog](https://github.com/dlesbre/bibtex-autocomplete/blob/master/CHANGELOG.md) for full details.



  ![demo.svg](https://raw.githubusercontent.com/dlesbre/bibtex-autocomplete/2d1a01f5ec94c8af9c2f3c1a810eca51bb4cce74/imgs/demo.svg)



  **How does it find matches?**

  `btac` queries the websites using the entry DOI (if known) or its title. So
  entries that don't have one of those two fields *will not* be completed.
  - DOIs are only used if they can be recognized, so the `doi` field should
    contain "10.xxxx/yyyy" or an URL ending with it.
  - Titles should be the full title. They are compared excluding case and
    punctuation, but titles with missing words will not match.
  - If one or more authors are present, entries with no common authors will not
    match. Authors are compared using lower case last names only. Be sure to use
    one of the correct BibTeX formats for the author field:
    ```bibtex
    author = {First Last and Last, First and First von Last}
    ```
    (see
    [https://www.bibtex.com/f/author-field/](https://www.bibtex.com/f/author-field/)
    for full details)
  - If the year is known, entries with different years will also not match.

  **Disclaimers**

  - There is no guarantee that the script will find matches for your entries, or
    that the websites will have any data to add to your entries, (or even that the
    website data is correct, but that's not for me to say...)

  - The script is designed to minimize the chance of false positives - that is
    adding data from another similar-ish entry to your entry. If you find any such
    false positive please report them using the [issue
    tracker](https://github.com/dlesbre/bibtex-autocomplete/issues).

  **How are entries completed?**

  Once responses from all websites have been found, the script will add fields
  by performing a majority vote among the sources. To do so it uses smart
  normalization and merging tactics for each field:
  - Authors (and editors) match if they have same last names and, if both first
    names present, the first name of one is equal/an abbreviation of the other.
    Author list match they have at least one author in common.
  - ISSN and ISBN are normalized and have their check digits verified. ISBN are converted
    to their 13 digit representation
  - URL and DOI are checked for valid format, and further validated by querying
    them online to ensure they exist. DOI are normalized to strip any leading URL
    and converted to lowercase.
  - Many fields match with abbreviation detection (journal, institution, booktitle,
    organization, publisher, school and series). So `ACM` will match
    `Association for Computer Machinery`
  - Pages are normalized to use `--` as separator
  - All other fields are compared excluding case and punctuation.

  The script will not overwrite any user given non-empty fields, unless the
  `-f/--force-overwrite` flag is given. If you want to check what fields are
  added, you can use `-v/--verbose` to have them printed to stdout (with
  source information), or `-p/--prefix` to have the new fields be prefixed with
  `BTAC` in the output file.



  Can be installed with [pip](https://pypi.org/project/pip/) :

  ```console
  pip install bibtexautocomplete
  ```

  You should now be able to run the script using either command:

  ```console
  btac --version
  python3 -m bibtexautocomplete --version
  ```

  **Note:** `pip` no longer allows installing scripts globally in systems with other
  package managers (like most Linux distros). You can install the script locally in
  a [virtual environment](https://docs.python.org/3/library/venv.html) or globally
  using [pipx](https://pipx.pypa.io/stable/):

  ```console
  sudo apt install pipx
  pipx install bibtexautocomplete
  ```



  If you want tab based completion for `btac` in your shell, you must install
  the optional [argcomplete](https://pypi.org/project/argcomplete/) dependency.
  ```bash

  pip install argcomplete

  pip install bibtexautocomplete[tab]
  ```
  You then need to register the tab auto-completer. On bash/zsh:
  - You can activate completion just for this script with
    ```bash
    eval "$(register-python-argcomplete btac)"
    ```
    For repeated use, I recommend adding this line to your `.bashrc` or `.bash_profile`.
  - Alternatively, you can activate completion for all python scripts
    using argcomplete by running
    ```bash
    activate-global-python-argcomplete
    ```
    and then restarting your shell

  If using another shell than bash/zsh on Linux or MacOS, support is not guaranteed.
  See [github.com/kislyuk/argcomplete/contrib](https://github.com/kislyuk/argcomplete/tree/develop/contrib) for instructions on getting it working on other shells.



  This package has two dependencies (automatically installed by pip) :

  - [bibtexparser](https://bibtexparser.readthedocs.io/) (<2.0.0)
  - [alive_progress](https://github.com/rsalmei/alive-progress) (>= 3.0.0) for the fancy progress bar

  It also has an optional dependency, [argcomplete](https://pypi.org/project/argcomplete/) for tab based completion. It is installed if you `pip install  bibtexautocomplete[tab]`.



  The command line tool can be used as follows:
  ```console
  btac [--flags] <input_files>
  ```

  **Examples :**

  - `btac my/db.bib` : reads from `./my/db.bib`, writes to `./my/db.btac.bib`.
    A different output file can be specified with `-o`.
  - `btac -i db.bib` : reads from `db.bib` and overwrites it (inplace flag).
    Avoid on non backed-up/version-controlled files, I'd hate it if my script
    corrupted your data.
  - `btac folder` : reads from all files ending with `.bib` in folder. Excludes
    `.btac.bib` files unless they are the only `.bib` files present. Writes to
    `folder/file.btac.bib` unless inplace flag is set.
  - `btac` with no inputs is same as `btac .`, reads file from current working directory
  - `btac -c doi ...` only completes DOI fields, leave others unchanged
  - `btac -v ...` verbose mode, pretty prints all new fields when done.
    See [this image](https://raw.githubusercontent.com/dlesbre/bibtex-autocomplete/master/imgs/btac-verbose.png) for a preview of verbose output.

  **Note:** the [parser](https://pypi.org/project/bibtexparser/) doesn't preserve
  format information, so this script will reformat your files. Some [formatting
  options](#output-formatting) are provided to control output format.

  **Slow responses:** Sometimes due to server traffic, a source DB may take significantly longer
  to respond and slow `btac`.
  - You can increase timeout with `btac ... -t 60` (60s) or `btac ... -t -1` (no timeout)
  - You can disable queries to the offender `btac ... -Q <website>`
  - You can try again at another time



  As `btac` has a lot of option I'd recommend setting up an alias if you use a lot
  regularly.



  - `-o --output <file.bib>`

    Write output to given file. Can be used multiple times when also giving
    multiple inputs. Maps inputs to outputs in order. If there are extra inputs,
    uses default name (`old_name.btac.bib`). Ignored in inplace (`-i`) mode.

    For example `btac db1.bib db2.bib db3.bib -o out1.bib -o out2.bib` reads `db1.bib`,
    `db2.bib` and `db3.bib`, and write their outputs to `out1.bib`, `out2.bib`
    and `db3.btac.bib` respectively.

  - `-i --inplace` Modify input files inplace, ignores any specified output files.
    Avoid on non backed-up/version-controlled files, I'd hate it if my script
    corrupted your data.

  - `-O --no-output` don't write any output files (except the one specified by `--dump-data`)
    can be used with `-v/--verbose` mode to only print a list of changes to the terminal



  - `-q --only-query <site>` or `-Q --dont-query <site>`

    Restrict which websites to query from. `<site>` must be one of: `openalex`,
    `crossref`, `arxiv`, `s2`, `unpaywall`, `dblp`, `researchr`, `hep`. These arguments
    can be used multiple times, for example to only query Crossref and DBLP use
    `-q crossref -q dblp` or
    `-Q openalex -Q researchr -Q unpaywall -Q arxiv -Q s2 -Q hep`

  - `-e --only-entry <id>` or `-E --exclude-entry <id>`

    Restrict which entries should be autocompleted. `<id>` is the entry ID used in
    your BibTeX file (e.g. `@inproceedings{<id> ... }`). These arguments can also
    be used multiple times to select only/exclude multiple entries

  - `--sf --start-from <id>`

    Only complete the entries that come after the given id (inclusive). This is
    useful when resuming a previously interrupted auto-completion on the same file.

  - `-c --only-complete <field>` or `-C --dont-complete <field>`

    Restrict which fields you wish to autocomplete. Field is a BibTeX field (e.g.
    `author`, `doi`,...). So if you only wish to add missing DOIs use `-c doi`.

  - `-b --filter-fields-by-entrytype <required|optional|all>` only add fields that correspond to
    the given entry type in bibtex's data model. Disabled by default. `required`
    only adds required fields, `optional` adds required and optional fields, and
    `all` adds required, optional and non-standard fields (doi, issn and isbn).
    A list of required/optional fields by entry type can be found
    [on the tex stackexchange](https://tex.stackexchange.com/questions/239042/where-can-we-find-a-list-of-all-available-bibtex-entries-and-the-available-fiel)

  - `-w --overwrite <field>` or `-W --dont-overwrite <field>`

    Force overwriting of the selected fields. If using `-W author -W journal`
    your force overwrite of all fields except `author` and `journal`. The
    default is to override nothing (only complete absent and blank fields).

    For a more complex example `btac -C doi -w author` means complete all fields
    save DOI, and only overwrite author fields.

    You can also use the `-f` flag to overwrite everything or the `-p` flag to add
    a prefix to new fields, thus avoiding overwrites.

  - `-m --mark` and `-M --ignore-mark`

    This is useful to avoid repeated queries if you want to run `btac` many times
    on the same (large) file.

    By default, `btac` ignores any entry with a `BTACqueried` field. `--ignore-mark`
    overrides this behavior.

    When `--mark` is set, `btac` adds a `BTACqueried = {yyyy-mm-dd}` field to each entry
    it queries.



  You can use the following arguments to control how `btac` formats the new fields
  - `--fu --escape-unicode` replace unicode symbols by latex escapes sequence (for
    example: replace `é` with `{\'e}`). The default is to keep unicode symbols as is.
  - `--fp --protect-uppercase <field>` or `--FP --dont-protect-uppercase <field>` or
    `--fpa --protect-all-uppercase`, insert braces around words containing uppercase
    letters in the given fields to ensure bibtex will preserve them. The three
    arguments are mutually exclusive, and the first two can be used multiple times
    to select/deselect multiple fields.




  Unfortunately [bibtexparser](https://pypi.org/project/bibtexparser/) doesn't
  preserve format information, so this script will reformat your BibTeX file. Here
  are a few options you can use to control the output format:

  - `--fa --align-values` pad field names to align all values

    ```bibtex
    @article{Example,
      author = {Someone},
      doi    = {10.xxxx/yyyyy},
    }
    ```

  - `--fc --comma-first` use comma first syntax

    ```bibtex
    @article{Example
      , author = {Someone}
      , doi = {10.xxxx/yyyyy}
      ,
    }
    ```

  - `--fl --no-trailing-comma` don't add the last trailing comma
  - `--fi --indent <space>` space used for indentation, default is a tab.
    Can be specified as a number (number of spaces) or a string with spaces
    and `_`, `t`, and `n` characters to mark space, tabs and newlines.



  - `-p --prefix` Write new fields with a prefix. The script will add `BTACtitle =
    ...` instead of `title = ...` in the bib file. This can be combined with `-f`
    to safely show info for already present fields.

    Note that this can overwrite existing fields starting with `BTACxxxx`, even
    without the `-f` option.
  - `-f --force-overwrite` Overwrite already present fields. The default is to
    overwrite a field only if it is empty or absent
  - `-D --diff` only print the new fields in the output file. In this mode, old
    fields are removed and entries with no new fields are deleted. This cannot be
    used with the `-i --inplace` flag for safety reasons. If you really want to overwrite
    your input file (and delete a bunch of data in the process), you can do so with
    by specifying it explicitly via the `-o --output` option.
  - `-u --copy-doi-to-url` If a DOI is found but no URL, set the URL field
    to `https://dx.doi.org/<doi>`

  - `-t --timeout <float>` set timeout on request in seconds, default: 20.0 s,
    increase this if you are getting a lot of timeouts. Set it to -1 for no timeout.
  - `-S --ignore-ssl` bypass SSL verification. Use this if you encounter the error:
    ```
    [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: certificate has expired (_ssl.c:1129)
    ```
    Another (better) fix for this is to run `pip install --upgrade certifi` to update python's certificates.
  - `--ns --no-skip` disable skipping. By default, btac will skip queries to sources
    if they lag behind (>=10 queries remain or >=60s delay between queries) when
    2/3rds of the other sources have completed. This avoids having a single source
    slow down btac considerably.

  - `-d --dump-data <file.json>` writes matching entries to the given JSON files.

    This allows to see duplicate fields from different sources that are otherwise overwritten when merged into a single entry.

    The JSON file will have the following structure:

    ```json
    [
      {
        "entry": "<entry_id>",
        "new-fields": 8,
        "crossref": {
          "query-url": "https://api.crossref.org/...",
          "query-response-time": 0.556,
          "query-response-status": 200,
          "author" : "Lastname, Firstnames and Lastname, Firstnames ...",
          "title" : "super interesting article!",
          "..." : "..."
        },
        "openalex": ...,
        "arxiv": null, // null when no match found
        "unpaywall": ...,
        "dblp": ...,
        "researchr": ...,
        "inspire": ...
      },
      ...
    ]
    ```

  - `-v --verbose` verbose mode shows more info. It details entries as they are
    being processed and shows a summary of new fields and their source at the end.
    Using it more than once prints debug info (up to four times).

    Verbose mode looks like this:

    ![verbose-output.png](https://raw.githubusercontent.com/dlesbre/bibtex-autocomplete/master/imgs/btac-verbose.png)
  - `-s --silent` hide info and progress bar. Keep showing warnings and errors.
    Use twice to also hide warnings, thrice to also hide errors and four times to
    also hide critical errors, effectively killing all output.
  - `-n --no-color` don't use ANSI codes to color and stylize output

  - `--version` show version number
  - `-h --help` show help



  You can call the main function of this script from python directly, specifying
  a list of arguments as you would on the command line:
  ```python
  from bibtexautocomplete import main

  main(["file.bib", "-o", "output.bib"])
  ```

  For more interactivity and more varied inputs/outputs than reading from files and
  writing to files, use the `BibtexAutocomplete` class. Here is a small demonstration:
  ```python
  from bibtexautocomplete import BibtexAutocomplete




  completer = BibtexAutocomplete(**settings)



  completer.load_file("ex.bib")
  completer.load_file(["ex1.bib", "ex2.bib"])

  completer.load_string(bibtex)
  completer.load_string([bibtex1, bibtex2])


  completer.load_entry({
    "author": "John Doe",
    "title": "My Awesome Paper",
    "ID": "foo",
    "ENTRYTYPE": "article"
  })

  completer.load_entry({
    "author": [{"firstname": "John"}, {"lastname": "Doe"}],
    "title": "My Awesome Paper",
    "ID": "foo",
    "ENTRYTYPE": "article"
  })


  completer.autocomplete()







  completer.write_file("ex.btac.bib")
  completer.write_file(["ex1.bib", "ex2.bib"])
  completer.write_string() # type: list[str]
  completer.write_entry() # type: list[list[EntryType]]
  ```

  The settings passed to the `BibtexAutocomplete` constructor mirror the
  command-line arguments, see [their documentation](#command-line-arguments) for
  details.
  ```python
  lookups: Iterable[LookupType] = ...,

  entries: Optional[Container[str]] = None,
  mark: bool = False,
  ignore_mark: bool = False,
  prefix: bool = False,
  escape_unicode: bool = False,
  diff_mode: bool = False,

  fields_to_complete: Optional[Set[FieldType]] = None,

  fields_to_overwrite: Optional[Set[FieldType]] = None,

  fields_to_protect_uppercase: Container[str] = set(),
  filter_by_entrytype: Literal["no", "required", "optional", "all"] = "no",
  copy_doi_to_url: bool = False,
  start_from: Optional[str] = None,
  dont_skip_slow_queries: bool = False,
  timeout: Optional[float] = 20,  # Timeout on all queries, in seconds
  ignore_ssl: bool = False,  # Bypass SSL verification
  verbose: int = 0,  # Verbosity level, from 4 (very verbose debug) to -3 (no output)

  align_values: bool = False,
  comma_first: bool = False,
  no_trailing_comma: bool = False,
  indent: str = "\t",
  ```




  This project was first inspired by the solution provided by
  [thando](https://tex.stackexchange.com/users/182467/thando) in this
  [TeX stack exchange post](https://tex.stackexchange.com/questions/6810/automatically-adding-doi-fields-to-a-hand-made-bibliography). I worked on as
  part of a course on
  [Web data management](https://moodle.r2.enst.fr/moodle/course/view.php?id=142) in
  2021-2022 as part of my masters ([MPRI](https://wikimpri.dptinfo.ens-cachan.fr/doku.php)).

  This project is free and open-source. It is distributed under terms of the
  [MIT License](https://choosealicense.com/licenses/mit/). See the
  [LICENSE](https://github.com/dlesbre/bibtex-autocomplete/blob/master/LICENSE)
  file for more information

rpm_license:
  MIT License  Copyright (c) 2022-2024 Dorian Lesbre  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: 511a75c5ef75b90dd74640612dd051f8f9105f830734180208f660fa5692b2ca
name: python-bibtexvcs
arch: src
version: 2015.16
epoch: 0
release: 1
summary: a Python package for managing a BibTeX database and related documents
url: http://github.com/supermihi/bibtevxcs
rpm_license: GPL3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibtexvcs-2015.16-1.src.rpm
checksum_type: sha256
description:
  Collecting and managing bibliography information can be cumbersone. Therefore it makes sense to maintain
  a single BibTeX database within a research group that focusses on the same topic and thus has a lot of
  common bibliography. Furthermore, tools like JabRef_ allow to link PDF documents to BibTeX entries, turning
  the ``bib`` file into a valuable literature database.
  Since the ``bib`` file is text-based, it can be efficiently put under revision control. However, such a database
  used by several people over a long period of time tends to become messy. Furthermore, most people are not
  trained, and even less interested in, the usage of VCS systems.
  `BibTeX VCS` resolves these issues by automating the most common VCS operations and providing a minimalist,
  platform-independent GUI. It allows to defined a number of `database checks` that are run prior to each
  commit operation, in order to enforce consistency and a defined referencing style within the database.
  For example, there is a check that ensures that the documents linked to BibTeX entries actually exist, and
  each PDF document is linked to by at least one BibTeX entry. For information on the default checks and how to
  add custom ones, see :ref:`checksModule`.


pkgId: 5ccc06d64e8944322102030b2d328d012d7d50f570be2f18927995502b3b164f
name: python-bibtheque
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: Bibliography management tool.
url: https://github.com/BibTheque/PyBibtheque
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibtheque-0.1.9-1.src.rpm
checksum_type: sha256
description:
  Command line program to organize and manage a bibliography or references.



  Connects to mongodb database via a URI.
  The details are in the config at `.config/bibtheque.toml`
  Run tests with `pytest`


  Still need to come up with a universal id system. I like doi and isbn but that doesn't work when a paper or book doesn't have that (like for a manual entry). I'm considering making a hash to id idea but I'm not sure if that's the best. I need to investigate particular hashes.

  I need to implement the side of bibtheque that outputs bibtex strings to a bib file with correct ids for use in an article

  Fill out the argument parser help doc.

  Integrate tags and notes in the cli.py



  `pip install -e <path>` to install and run



  https://www.bibtex.com/format/



  library
  |- database.json
  |- raw/
  |- annotated/
  |- .gitignore



  bibtheque init

  - make library folder and folder structure
  - make database.json
  - make default config at .config/bibtheque.yml
  - make .gitignore with raw/ and annotated/ in it




  insert files with `insert -f` ? (f flag for file?)

  original filename is stored
  file is renamed according to uuid given to it and moved
  when entry is called, original file is returned (uuid.pdf renamed original.pdf)



  use git for database.json and config





  article
  book
  booklet
  conference (same as inproceedings)
  inbook
  incollection
  inproceedings
  manual
  mastersthesis
  misc
  phdthesis
  proceedings
  techreport
  unpublished



  type
  - required
  - optional

  article
  - author, title, journal, year, volume
  - number, pages, month, doi, note, key

  book
  - author or editor, title, publisher, year
  - volume or number, series, address, edition, month, note, key, url

  booklet
  - title
  - author, howpublished, address, month, year, note, key

  conference (see inproceedings)

  inbook
  - author or editor, title, chapter or pages, publisher, year
  - volume or number, series, type, address, edition, month, note, key

  incollection
  - author, title, booktitle, publisher, year
  - editor, volume or number, series, type, chapter, pages, address, edition, month, note, key

  inproceedings
  - author, title, booktitle, year
  - editor, volume or number, series, pages, address, month, organization, publisher, note, key

  manual
  - title
  - author, organization, address, edition, month, year, note, key

  mastersthesis
  - author, title, school, year
  - type, address, month, note, key

  misc
  -
  - author, title, howpublished, month, year, note, key

  phdthesis
  - author, title, school, year
  - type, address, month, note, key

  proceedings
  - title, year
  - editor, volume or number, series, address, month, publisher

  techreport
  - author, title, institution, year
  - type, number, address, month, note, key

  unpublished
  - author, title, note
  - month, year, key



  address
  annote
  author
  booktitle
  Email
  chapter
  crossref
  doi
  edition
  editor
  howpublished
  institution
  journal
  key
  month
  note
  number
  organization
  pages
  publisher
  school
  series
  title
  type
  volume
  year



  all bibtex fields
  read flag
  tags
  organization tags
  synopsis
  annotations
  raw_path
  annotated_path



  doc_dict
  - bib_dict (dict) -> doc_dict['bib']
      - fields (str)
  - read flag (bool)
  - tags (list) -> including project labels
  - synopsis (str)
  - notes (str)
  - path_dict (dict) -> doc_dict['path']
      - raw_path (str)
      - annotated_path (str)



  - type
      - alphabetical order of required fields

  Connect:

  ```
  mongosh "mongodb://144.44.44.44" --username root --password pass
  ```


      doc = {}

      doc['bib'] = bib_dict

      if file_text:
          doc['file_text'] = file_text

      if file_path:
          doc['file_path'] = file_path

      if annotated_path:
          doc['annotated_path'] = annotated_path

      
      doc['tags'] = tags

      if notes:
          doc['notes'] = notes

      if synopsis:
          doc['synopsis'] = synopsis


pkgId: ffb24985bcd89a5505e18941331829a01cba3488f737c0cc05284a26eaf20879
name: python-bibtutils
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Functionality often used by BITS Blue Team. [DEPRECATED]
url: https://github.com/broadinstitute/bibtutils
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibtutils-2.0.1-1.src.rpm
checksum_type: sha256
description:
  - **Developer**: Matthew OBrien
  - **Email**: mobrien@broadinstitute.org
  - **Project URL**: https://pypi.org/project/bibtutils/
  - **Project Repo**: https://github.com/broadinstitute/bibtutils
  - **Project Documentation**: https://bibtutils.readthedocs.io/en/latest/

  ```bash
  $ pip install --upgrade bibtutils
  ```

  - Requires Docker to be installed on your system.
  - Clone this repo and create & run the test container:
  ```
  $ docker build -f ./Dockerfile -t bibtutils-test . && docker run bibtutils-test
  ```

  - See documentation here: https://bibtutils.readthedocs.io/en/latest/


pkgId: d88053e350248d250039ab99d4887b1457e61234fe13f5440a3c59fbba5c8f0b
name: python-bibx
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Python bibliometric tools.
url: https://pypi.org/project/bibx/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bibx-0.1.1-1.src.rpm
checksum_type: sha256
description:
  A python library with bibliographic and biblio-metric tools.



  - Reads Web of Science (ISI) files.
  - Reads scopus bibtex files.
  - Merges scopus and ISI bibliographic collections.
  - Implements the [SAP][sap] algorithm.
  - More features in the roadmap...



  Here's how to apply the sap algorithm:

  ```python
  from bibx import read_scopus, Sap

  with open('./docs/examples/scopus.bib') as f:
      c = read_scopus(f)
  s = Sap()
  g = s.create_graph(c)
  g = s.clean_graph(g)
  g = s.tree(g)

  ```



  - Zuluaga, M.; Robledo, S.; Arbelaez-Echeverri, O.; Osorio-Zuluaga, G. A. & Duque-Méndez, N. (2022). Tree of Science - ToS: A web-based tool for scientific literature recommendation. Search less, research more! _Issues In Science And Technology Librarianship_, 100. [https://dx.doi.org/10.29173/istl2696][web]
  - Valencia-Hernandez, D. S., Robledo, S., Pinilla, R., Duque-Méndez, N. D., & Olivar-Tost, G. (2020). SAP Algorithm for Citation Analysis: An improvement to Tree of Science. _Ingeniería E Investigación_, 40(1), 45–49. [https://doi.org/10.15446/ing.investig.v40n1.77718][sap]
  - Zuluaga, M.; Robledo, S.; Osorio-Zuluaga, G. A.; Yathe, L.; González, D. & Taborda, G. (2016). Metabolomics and pesticides: systematic literature review usinggraph theory for analysis of references. _Nova_, 14(25), 121-138. [https://dx.doi.org/10.22490/24629448.1735][meta]
  - Robledo, S.; Osorio, G. & López, C. (2014). Networking en pequeña empresa: una revisión bibliográfica utilizando la teoria de grafos. _Revista Vínculos_, 11(2), 6-16. [https://dx.doi.org/10.14483/2322939X.9664][network]

  [web]: https://dx.doi.org/10.29173/istl2696
  [sap]: https://dx.doi.org/10.15446/ing.investig.v40n1.77718
  [meta]: https://dx.doi.org/10.22490/24629448.1735
  [network]: https://dx.doi.org/10.14483/2322939X.9664


pkgId: e870909be8e0a9396ea359510a74296826ea684ea40c0946e387c89096fe698b
name: python-bicchiere
arch: src
version: 1.9.5
epoch: 0
release: 1
summary: Yet another python web (WSGI) micro-framework
url: https://github.com/sandy98/bicchiere
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bicchiere-1.9.5-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">Bicchiere</h1>


  <p align="center"><img title="Un bel bicchiere di Campari" src="https://bicchiere.sytes.net/static/img/bicchiere-rosso-2.jpg" alt="Bicchiere Logo"/></p>



  Following [Flask](https://flask.palletsprojects.com/en/2.1.x/) and [Bottle](https://bottlepy.org/docs/dev/) footsteps, adding a bit of italian flavor :-)


  ```bash
  pip install bicchiere
  ```



  Current version: 1.9.5

  <p>
      <a href="https://pypi.python.org/pypi/bicchiere" target="_blank" rel="nofollow"><img alt="GitHub tag (latest by date)" src="https://img.shields.io/github/v/tag/sandy98/bicchiere?color=%230cc000&label=bicchiere"></a>
      &nbsp;&nbsp;&nbsp;
      <a href="https://pepy.tech/project/bicchiere" rel="nofollow" target="_blank">
          <img src="https://static.pepy.tech/personalized-badge/bicchiere?period=total&units=international_system&left_color=black&right_color=blue&left_text=Downloads"/>
      </a>
  </p>




  ```python
  from bicchiere import Bicchiere

  app = Bicchiere()
  or
  app = Bicchiere("La mia bella App")

  @app.get("/")
  def home():
      return "Bon giorno, cosa bevete oggi?"

  if __name__ == "__main__":
      
      app.run()
  ```

  ... and this is just about the classical WSGI **Hello, World**, for everything else please refer to [Bicchiere Wiki](https://github.com/sandy98/bicchiere/wiki)

  Well... not really. A bit of rationale is in order here.

  So, why Bicchiere?

  - For one thing, reinventing the wheel is not only fun but highly educational, so, by all means, do it!

  - I like Flask and Bottle. A lot. Both have things that I highly appreciate, simplicity in the first
    place. But it doesn't end there.
  - There's also the single file/no dependencies approach (Bottle), which I intend to mimic with Bicchiere. Although not a   mandatory thing, I like  it that way.
  - Built-in sessions (Flask). Although the user of the library must be free to choose whatever he likes regarding sessions or any other component of the application for that matter, I think session-handling is one of those must-have things in any web app these days. So, I provided basic session handling mechanism, in 3 flavors: memory, filesystem, and sqlite. This was the most that could be done without falling out of the boundaries of the Python Standard Library. Details on this at [the wiki (under construction)](https://github.com/sandy98/bicchiere/wiki/Bicchiere-session)
  - Built-in templating mechanism (Bottle). Similar considerations apply. In my opinion, this is also a must have, regardless how micro is the framework/library. Then again, end-user must be free to choose. As a good WSGI compliant middleware, Bicchiere doesn't come in the way of the user if he prefers to use [Mako](https://www.makotemplates.org/), [Jinja2](https://jinja.palletsprojects.com/en/3.1.x/), [Genshi](https://genshi.edgewall.org/) or whatever he likes. Details at [the wiki (under construction)](https://github.com/sandy98/bicchiere/wiki/Bicchiere-templates)
  - WebSockets handling: to me, this is the fruit on the cake, for various reasons:
      1. It's been said that it can't be done under WSGI, reason the more to do it.
      2. Real time communication looks like another must have in the current landscape of web app development
      3. Then again, its a lot of fun. A lot of pain, too...
  In any case, Bicchiere comes bundled with native WebSocket support - just taken out from the oven :-))
  Details at [the wiki (under construction)](https://github.com/sandy98/bicchiere/wiki/Bicchiere-Websocket) . Regretably, [the original Demo App](https://bicchiere.eu.pythonanywhere.com) won't work with websockets, because **Pythonanywhere** hasn't yet implemented the feature. As of now, there's a mirror at [bicchiere.sytes.net](http://bicchiere.sytes.net) which works fine, test at the home page and all. In any case, these issues are related to reverse proxy configuration and have nothing to see with the app/library itself.
  - And still, there's a lot of stuff to be mentioned. More to come...

rpm_license:
  MIT License Copyright (c) 2022 Domingo Ernesto Savoretti Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: 3f8f3e4da580edba238df503ddd7773a5e70ef5f569f888b22597c50b949f23e
name: python-bicleaner
arch: src
version: 0.17.4
epoch: 0
release: 1
url: https://github.com/bitextor/bicleaner
rpm_license: GNU General Public License v3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bicleaner-0.17.4-1.src.rpm
checksum_type: sha256
summary:
  Parallel corpus classifier, indicating the likelihood of a pair of sentences being mutual translations or not

description:
  ![License](https://img.shields.io/badge/License-GPLv3-blue.svg)


  Bicleaner (`bicleaner-classify`) is a tool in Python that aims at detecting noisy sentence pairs in a parallel corpus. It
  indicates the likelihood of a pair of sentences being mutual translations (with a value near to 1) or not (with a value near to 0). Sentence pairs considered very noisy are scored with 0.

  Although a training tool (`bicleaner-train`) is provided, you may want to use the available ready-to-use language packages.
  Please, visit https://github.com/bitextor/bicleaner-data/releases/latest or use `bicleaner-download` to download the latest language packages.
  Visit our [Wiki](https://github.com/bitextor/bicleaner/wiki/How-to-train-your-Bicleaner) for a detailed example on Bicleaner training.



  If you find Bicleaner useful, please consider citing the following papers:

  > V. M. Sánchez-Cartagena, M. Bañón, S. Ortiz-Rojas and G. Ramírez-Sánchez,\
  > "[Prompsit's submission to WMT 2018 Parallel Corpus Filtering shared task](http://www.statmt.org/wmt18/pdf/WMT116.pdf)",\
  >in *Proceedings of the Third Conference on Machine Translation, Volume 2: Shared Task Papers*.\
  >Brussels, Belgium: Association for Computational Linguistics, October 2018

  ```latex
  @InProceedings{prompsit:2018:WMT,
    author    = { V\'{i}ctor M. S\'{a}nchez-Cartagena and Marta Ba{\~n}\'{o}n and Sergio Ortiz-Rojas and Gema Ram\'{i}rez-S\'{a}nchez},
    title     = {Prompsit's submission to WMT 2018 Parallel Corpus Filtering shared task},
    booktitle = {Proceedings of the Third Conference on Machine Translation, Volume 2: Shared Task Papers},
    month     = {October},
    address   = {Brussels, Belgium},
    publisher = {Association for Computational Linguistics}
  }
  ```


  > Gema Ramírez-Sánchez, Jaume Zaragoza-Bernabeu, Marta Bañón and Sergio Ortiz Rojas \
  > "[Bifixer and Bicleaner: two open-source tools to clean your parallel data.](https://eamt2020.inesc-id.pt/proceedings-eamt2020.pdf#page=311)",\
  >in *Proceedings of the 22nd Annual Conference of the European Association for Machine Translation*.\
  >Lisboa, Portugal: European Association for Machine Translation, November 2020

  ```latex
  @InProceedings{prompsit:2020:EAMT,
    author    = {Gema Ram\'{i}rez-S\'{a}nchez and Jaume Zaragoza-Bernabeu and Marta Ba{\~n}\'{o}n and Sergio Ortiz-Rojas},
    title     = {Bifixer and Bicleaner: two open-source tools to clean your parallel data.},
    booktitle = {Proceedings of the 22nd Annual Conference of the European Association for Machine Translation},
    pages	    = {291--298},
    isbn      = {978-989-33-0589-8},
    year	    = {2020},
    month     = {November},
    address   = {Lisboa, Portugal},
    publisher = {European Association for Machine Translation}
  }
  ```



  Bicleaner is written in Python and can be installed using pip. It also requires the KenLM Python bindings with support for 7-gram language models. You can easily install it by running the following commands:

  ```bash
  pip install bicleaner
  pip install --config-settings="--build-option=--max_order=7" https://github.com/kpu/kenlm/archive/master.zip
  ```

  The remaining extra modules required by Bicleaner will be automatically downloaded and installed/upgraded (if required) with the first command.

  Also, you can install the conda package (KenLM is already included):

  ```bash
  conda install -c conda-forge -c bitextor bicleaner
  ```

  After installation, three binary files (`bicleaner-train`, `bicleaner-classify` and `bicleaner-classify-lite`) will be located in your `python/installation/prefix/bin` directory. This is usually `$HOME/.local/bin` or `/usr/local/bin/`.



  `bicleaner-classify` aims at detecting noisy sentence pairs in a parallel corpus. It
  indicates the likelihood of a pair of sentences being mutual translations (with a value near to 1) or not (with a value near to 0). Sentence pairs considered very noisy are scored with 0.

  By default, the input file (the parallel corpus to be classified) must contain at least four columns, being:

  * col1: URL 1
  * col2: URL 2
  * col3: Source sentence
  * col4: Target sentence

  but the source and target sentences column index can be customized by using the `--scol` and `--tcol` flags.

  The generated output file will contain the same lines and columns that the original input file had, adding an extra column containing the Bicleaner classifier score.

  This tool can be run with

  ```bash
  bicleaner-classify [-h]
                     [-S SOURCE_TOKENIZER_COMMAND]
                     [-T TARGET_TOKENIZER_COMMAND]
                     [--header]
                     [--scol SCOL]
                     [--tcol TCOL]
                     [--tmp_dir TMP_DIR]
                     [-b BLOCK_SIZE]
                     [-p PROCESSES]
                     [-d DISCARDED_TUS]
                     [--lm_threshold LM_THRESHOLD]
                     [--score_only]
                     [--disable_hardrules]
                     [--disable_lm_filter]
                     [--disable_porn_removal]
                     [--disable_minimal_length]
                     [-q]
                     [--debug]
                     [--logfile LOGFILE]
                     [-v]
                     input
                     [output]
                     metadata
  ```



  * positional arguments:
    * `input`: Tab-separated files to be classified (default line format: `URL1 URL2 SOURCE_SENTENCE TARGET_SENTENCE [EXTRA_COLUMNS]`, tab-separated). When input is -, reads standard input.
    * `output`: Output of the classification (default: standard output). When output is -, writes standard output.
    * `metadata`: Training metadata (YAML file), generated by `bicleaner-train` or [downloaded](https://github.com/bitextor/bicleaner-data/releases/latest) as a part of a language pack. You just need to `untar` the language pack for the pair of languages of the file you want to clean. The tar file contains the YAML metadata file.
    There's a script that can download and unpack it for you, use:
    ```bash
    $ ./utils/download-pack.sh en cs ./models
    ```
    to download English-Czech language pack to the ./models directory and unpack it.
  * optional arguments:
    * `-h, --help`: show this help message and exit
  * Optional:
    * `-S SOURCE_TOKENIZER_COMMAND`: Source language tokenizer full command (including flags if needed). If not given, Sacremoses tokenizer is used (with `escape=False` option).
    * `-T TARGET_TOKENIZER_COMMAND`: Target language tokenizer full command (including flags if needed). If not given, Sacremoses tokenizer is used (with `escape=False` option).
    * `--header`: Treats the first sentence of the input file as the header row. If set, the output will contain a header as well
    * `--scol SCOL`: Source sentence column (starting in 1). If `--header` is set, the expected value will be the name of the field (default: 3 if `--header` is not set else src_text)
    * `--tcol TCOL`: Target sentence column (starting in 1). If `--header` is set, the expected value will be the name of the field (default: 4 if `--header` is not set else trg_text)
    * `--tmp_dir TMP_DIR`: Temporary directory where creating the temporary files of this program (default: default system temp dir, defined by the environment variable TMPDIR in Unix)
    * `-b BLOCK_SIZE, --block_size BLOCK_SIZE`: Sentence pairs per block (default: 10000)
    * `p PROCESSES, --processes PROCESSES`: Number of processes to use (default: all CPUs minus one)
    * `-d DISCARDED_TUS, --discarded_tus DISCARDED_TUS`: TSV file with discarded TUs. Discarded TUs by the classifier are written in this file in TSV file. (default: None)
    * `--lm_threshold LM_THRESHOLD`: Threshold for language model fluency scoring. All sentence pairs whose LM fluency score falls below the threshold are removed (classifier score set to 0), unless the option --keep_lm_result is set. (default: 0.5)
    * `--score_only`: Only output one column which is the bicleaner score (default: False)
    * `--disable_hardrules`: Disables the bicleaner_hardrules filtering (only bicleaner_classify is applied) (default: False)
    * `--disable_lm_filter`: Disables LM filtering.
    * `--disable_porn_removal`: Disables porn removal.
    * `--disable_minimal_length` : Don't apply minimal length rule (default: False).

  * Logging:
    * `-q, --quiet`: Silent logging mode (default: False)
    * `--debug`: Debug logging mode (default: False)
    * `--logfile LOGFILE`: Store log to a file (default: <_io.TextIOWrapper name='<stderr>' mode='w' encoding='UTF-8'>)
    * `-v, --version`: show version of this script and exit



  ```bash
  bicleaner-classify  \
          corpus.en-es.raw  \
          corpus.en-es.classifed  \
          training.en-es.yaml
  ```

  This will read the "`corpus.en-es.raw`" file,
  classify it with the classifier indicated in the "`training.en-es.yaml`" metadata file,
  writing the result of the classification in the "`corpus.en-es.classified`" file.
  Each line of the new file will contain the same content as the input file, adding a column with the score given by the Bicleaner classifier.



  We included a small test corpus and a script to check that your Bicleaner classifier is working as expected.
  In order to use it, just run:

  ```bash
  python -m pytest -s tests/bicleaner_test.py
  ```

  This will download the required language pack, classify the provided test corpus, and check the resulting classification scores. If everything went as expected, the output will be "1 passed in XX.XX seconds". All downloaded data will be removed at the end of the testing session.



  In case you need to train a new classifier (i.e. because it is not available in the language packs provided at [bicleaner-data](https://github.com/bitextor/bicleaner-data/releases/latest)), you can use `bicleaner-train` .
  `bicleaner-train` is a Python3 tool that allows you to train a classifier which predicts
  whether a pair of sentences are mutual translations or not and discards too noisy sentence pairs. Visit our [Wiki](https://github.com/bitextor/bicleaner/wiki/How-to-train-your-Bicleaner) for a detailed example on Bicleaner training.



  In order to train a new classifier, you must provide:
  * A clean parallel corpus (100k pairs of sentences is the recommended size).
  * SL-to-TL and TL-to-SL gzipped probabilistic bilingual dictionaries. You can check their format by downloading any of the available language packs.
     * The SL-to-TL probabilistic bilingual dictionary must contain one entry per line. Each entry must contain the following 3 fields, split by space, in this order: TL word, SL word, probability.
     * The TL-to-SL probabilistic bilingual dictionary must contain one entry per line. Each entry must contain the following 3 fields, split by space, in this order: SL word, TL word, probability.
     * We recommend filtering out entries with a very low probability: removing those with a probability 10 times lower than the maximum translation probability for each word speeds up the process and does not decrease accuracy.
     * Prior to inferring the probabilistic dictionaries, sentences must be tokenizer with the Moses tokenizer (with the `-a` flag) and lowercased.
     * You can uses Moses and MGIZA++ to obtain probabilistic dictionaries from a parallel corpus.
     * Please note that both target and source words in probabilistic bilingual dictionaries must be single words.
  * Gzipped lists of monolingual word frequencies. You can check their format by downloading any of the available language packs.
     * The SL list of word frequencies with one entry per line. Each entry must contain the following 2 fields, split by space, in this order: word frequency (number of times a word appears in text), SL word.
     * The TL list of word frequencies with one entry per line. Each entry must contain the following 2 fields, split by space, in this order: word frequency (number of times a word appears in text), TL word.
     * These lists can easily be obtained from a monolingual corpus (i.e. newscrawl or the same text used to train probabilistic bilingual dictionaries) and a command line in bash:

  ```bash
  $ cat monolingual.SL \
      | sacremoses -l SL tokenize -x \
      | awk '{print tolower($0)}' \
      | tr ' ' '\n' \
      | LC_ALL=C sort | uniq -c \
      | LC_ALL=C sort -nr \
      | grep -v '[[:space:]]*1' \
      | gzip > wordfreq-SL.gz
  $ cat monolingual.TL \
      | sacremoses -l TL tokenize -x \
      | awk '{print tolower($0)}' \
      | tr ' ' '\n' \
      | LC_ALL=C sort | uniq -c \
      | LC_ALL=C sort -nr \
      | grep -v '[[:space:]]*1' \
      | gzip > wordfreq-TL.gz

  ```
  Optionally, if you want the classifier to include a porn filter, you must also provide:
  * File with training dataset for porn removal classifier. Each sentence must contain at the beginning the `__label__negative` or `__label__positive` according to FastText convention. It should be lowercased and tokenized.

  Optionally, if you want the classifier to include an improved fluency filter based on language models, you must also provide:
  * A monolingual corpus made ONLY of noisy sentences in the SL (100k sentences is the recommended size)
  * A monolingual corpus made ONLY of noisy sentences in the TL (100k sentences is the recommended size)

  If not provided, since Bicleaner `0.13`, noisy corpora is produced synthetically from the training corpus.

  Moreover, **`lmplz`, the command to train a KenLM language model must be in `PATH`**. See https://github.com/kpu/kenlm for instructions about its compilation and installation.

  In principle, if you want to use Bicleaner to clean a partially noisy corpus, it could be difficult to find a corpus made solely of noisy sentences. Fortunately, there are two options available with Bicleaner:



  Given a parallel corpus, you use `bicleaner-hardrules` to extract some of its noisiest sentences using heuristic rules by running the following command:

  ```bash
    bicleaner-hardrules [-h]
                        [--annotated_output]
                        -s SOURCE_LANG
                        -t TARGET_LANG
                        [--tmp_dir TMP_DIR]
                        [-b BLOCK_SIZE]
                        [-p PROCESSES]
                        [--disable_lang_ident]
                        [--disable_minimal_length]
                        [--header]
                        [--scol SCOL]
                        [--tcol TCOL]
                        [--disable_lm_filter]
                        [--disable_porn_removal]
                        [--metadata METADATA]
                        [--lm_threshold LM_THRESHOLD]
                        [-q]
                        [--debug]
                        [--logfile LOGFILE]
                        [input]
                        [output]
  ```

  where `INPUT_FILE` contains a sentence-aligned parallel corpus, with a sentence pair per line. Sentences are split by tab. `OUTPUT_FILE` will contain all the input sentences, with an extra score column with `0` (if the sentence is noisy and should be discarded) or `1` (if the sentence is ok). When the `--annotated_output` flag is in use, `OUTPUT_FILE` will contain another extra column, specifying the heuristic rule applied to decide discarding each sentence (or `keep`, if the sentence is ok and should not be discarded). If the `--disable_lang_ident` flag is in use, rules that require language identification are not used. '--scol' and '--tcol' allow to indicate which columns contains source and target in the input file (default: `1`and `2`, respectively).

  In order to use the LM filtering and/or porn removal, you must provide the `--metadata` (it is: the .yaml file generated by Bicleaner training).
  To disable LM filtering and/or porn removal, just use the `--disable_lm_filter` and/or `--disable_porn_removal` flags.

  You can then obtain the monolingual noisy corpora by "cutting" the appropriate columns (after running `bicleaner-hardrules` with the `--annotated_output` flag). Asuming scol=1 and tcol=2, and no more columns in the input corpus (so the hardrules score is the 3rd column in the output):

  ```bash
  cat OUTPUT_FILE | awk -F'\t' '{if ($3 == 0) print $1 }' > MONOLINGUAL_NOISY.SOURCE_LANG
  cat OUTPUT_FILE | awk -F'\t' '{if ($3 == 0) print $2 }' > MONOLINGUAL_NOISY.TARGET_LANG
  ```



  ```bash
  cat TRAINING_CORPUS | cut -f1 | python3.7 bicleaner/utils/shuffle.py - > MONOLINGUAL_NOISY.SOURCE_LANG
  cat TRAINING_CORPUS | cut -f2 | python3.7 bicleaner/utils/shuffle.py - > MONOLINGUAL_NOISY.TARGET_LANG
  ```

  Since `0.13`, if no noisy corpora is provided, it's produced by Bicleaner training itself, so it has become an optional parameter.



  It can be used as follows. Note that the parameters `--noisy_examples_file_sl`, `--noisy_examples_file_tl`, `--lm_file_sl`, `--lm_file_tl`, are mandatory if you want to enable improved fluency filter based on language models (recommended).


  ```bash
  bicleaner_train.py [-h]
      -m METADATA
      -c CLASSIFIER
      -s SOURCE_LANG
      -t TARGET_LANG
      -d SOURCE_DICTIONARY
      -D TARGET_DICTIONARY
      -f SOURCE_WORD_FREQS
      -F TARGET_WORD_FREQS
      [-S SOURCE_TOKENIZER_COMMAND]
      [-T TARGET_TOKENIZER_COMMAND]
      [--normalize_by_length]
      [--treat_oovs]
      [--qmax_limit QMAX_LIMIT]
      [--disable_features_quest]
      [--classifier_type {mlp,svm,nn,nn1,adaboost,random_forest,extra_trees}]
      [--dump_features DUMP_FEATURES]
      [-b BLOCK_SIZE]
      [-p PROCESSES]
      [--wrong_examples_file WRONG_EXAMPLES_FILE]
      [--features_version FEATURES_VERSION]
      [--disable_lang_ident]
      [--seed SEED]
      [--relative_paths]
      [--noisy_examples_file_sl NOISY_EXAMPLES_FILE_SL]
      [--noisy_examples_file_tl NOISY_EXAMPLES_FILE_TL]
      [--lm_dev_size LM_DEV_SIZE]
      [--lm_file_sl LM_FILE_SL]
      [--lm_file_tl LM_FILE_TL]
      [--lm_training_file_sl LM_TRAINING_FILE_SL]
      [--lm_training_file_tl LM_TRAINING_FILE_TL]
      [--lm_clean_examples_file_sl LM_CLEAN_EXAMPLES_FILE_SL]
      [--lm_clean_examples_file_tl LM_CLEAN_EXAMPLES_FILE_TL]
      [--porn_removal_train PORN_REMOVAL_TRAIN]
      [--porn_removal_test PORN_REMOVAL_TEST]
      [--porn_removal_file PORN_REMOVAL_FILE]
      [--porn_removal_side {sl,tl}]
      [-q] [--debug] [--logfile LOGFILE]
      [input]

  ```

  * positional arguments:
    * `input`: Tab-separated bilingual input file (default: Standard input)(line format: SOURCE_SENTENCE TARGET_SENTENCE, tab-separated)
  * optional arguments:
    * `-h, --help`: show this help message and exit
  * Mandatory:
    * `-m METADATA, --metadata METADATA`: Output training metadata (YAML file) that will be created after training.
    * `-c CLASSIFIER, --classifier CLASSIFIER`: Classifier data file that will be created after training.
    * `-s SOURCE_LANG, --source_lang SOURCE_LANG`: Source language code
    * `-t TARGET_LANG, --target_lang TARGET_LANG`: Target language code
    * `-d SOURCE_TO_TARGET_DICTIONARY, --source_dictionary SOURCE_TO_TARGET_DICTIONARY`: SL-to-TL gzipped probabilistic dictionary
    * `-D TARGET_TO_SOURCE_DICTIONARY, --target_dictionary TARGET_TO_SOURCE_DICTIONARY`: TL-to-SL gzipped probabilistic dictionary
    * `-f SOURCE_WORD_FREQ_DICTIONARY, --source_word_freqs SOURCE_WORD_FREQ_DICTIONARY`: SL gzipped word frequencies dictionary
    * `-F TARGET_WORD_FREQ_DICTIONARY, --target_word_freqs TARGET_WORD_FREQ_DICTIONARY`: TL gzipped word frequencies dictionary
  * Options:
    * `-S SOURCE_TOKENIZER_COMMAND`: Source language tokenizer full command (including flags if needed). If not given, Sacremoses tokenizer is used (with `escape=False` option).
    * `-T TARGET_TOKENIZER_COMMAND`: Target language tokenizer full command (including flags if needed). If not given, Sacremoses tokenizer is used (with `escape=False` option).
    * `--normalize_by_length`: Normalize by length in qmax dict feature
    * `--treat_oovs`: Special treatment for OOVs in qmax dict feature
    * `--qmax_limit`: Number of max target words to be taken into account, sorted by length (default: 20)
    * `--disable_features_quest`: Disable less important features
    * `--classifier_type {svm,nn,nn1,adaboost,random_forest,extra_trees}`: Classifier type (default: extra_trees)
    * `--dump_features DUMP_FEATURES`: Dump training features to file (default: None)
    * `-b BLOCK_SIZE, --block_size BLOCK_SIZE`: Sentence pairs per block (default: 10000)
    * `-p PROCESSES, --processes PROCESSES`: Number of process to use (default: all CPUs minus one)
    * `--wrong_examples_file WRONG_EXAMPLES_FILE`: File with wrong examples extracted to replace the synthetic examples from method used by default (default: None)
    * `--features_version FEATURES_VERSION`: Version of the feature (default: extracted from the features.py file)
    * `--disable_lang_ident`: Don't apply features that use language detecting (default: False). Useful when the language in use is too similar to other languages, making the automatic identification of language not realiable.
    * `--relative_paths`: Ask training to save model files by relative path if they are in the same directory as metadata. Useful if you are going to train distributable models. (default: False)
    * `--noisy_examples_file_sl NOISY_EXAMPLES_FILE_SL`: File with noisy text in the SL. These are used to estimate the perplexity of noisy text. (Optional)
    * `--noisy_examples_file_tl NOISY_EXAMPLES_FILE_TL`: File with noisy text in the TL. These are used to estimate the perplexity of noisy text. (Optional)
    * `--lm_dev_size SIZE`: Number of sentences to be removed from clean text before training LMs. These are used to estimate the perplexity of clean text. (default: 2000)
    * `--lm_file_sl LM_FILE_SL`: Output file with the created SL language model. This file should be placed in the same directory as the YAML training metadata, as they are usually distributed together.
    * `--lm_file_tl LM_FILE_TL`: Output file with the created TL language model. This file should be placed in the same directory as the YAML training metadata, as they are usually distributed together.
    * `--lm_training_file_sl LM_TRAINING_FILE_SL`: SL text from which the SL LM is trained. If this parameter is not specified, SL LM is trained from the SL side of the input file, after removing --lm_dev_size sentences.
    * `--lm_training_file_tl LM_TRAINING_FILE_TL`: TL text from which the TL LM is trained. If this parameter is not specified, TL LM is trained from the TL side of the input file, after removing --lm_dev_size sentences.
    * `--lm_clean_examples_file_sl LM_CLEAN_EXAMPLES_FILE_SL`: File with clean text in the SL. Used to estimate the perplexity of clean text. This option must be used together with --lm_training_file_sl and both files must not have common sentences. This option replaces --lm_dev_size.
    * `--lm_clean_examples_file_tl LM_CLEAN_EXAMPLES_FILE_TL`: File with clean text in the TL. Used to estimate the perplexity of clean text. This option must be used together with --lm_training_file_tl and both files must not have common sentences. This option replaces --lm_dev_size."
    * `--porn_removal_train PORN_REMOVAL_TRAIN`: File with training dataset for porn removal classifier. Each sentence must contain at the beginning the `'__label__negative'` or `'__label__positive'` according to FastText [convention](https://fasttext.cc/docs/en/supervised-tutorial.html#getting-and-preparing-the-data). It should be lowercased and tokenized.
    * `--porn_removal_test PORN_REMOVAL_TEST`: Test set to compute precision and accuracy of the porn removal classifier.
    * `--porn_removal_file PORN_REMOVAL_FILE`: Porn removal classifier output file.
    * `--porn_removal_side {sl,tl}`: Whether the porn removal should be applied at the source or at the target language. (default: sl)
  * Logging:
    * `-q, --quiet`: Silent logging mode (default: False)
    * `--debug`: Debug logging mode (default: False)
    * `--logfile LOGFILE`: Store log to a file (default: <_io.TextIOWrapper name='<stderr>' mode='w' encoding='UTF-8'>)



  ```bash
  bicleaner-train \
            corpus.en-cs.train\
            --normalize_by_length \
            -s en \
            -t cs \
            -d dict-en-cs.gz \
            -D dict-cs-en.gz \
            -f wordfreqs-en.gz \
            -F wordfreqs-cs.gz \
            -c en-cs.classifier \
            --lm_training_file_sl lmtrain.en-cs.en --lm_training_file_tl lmtrain.en-cs.cs \
            --lm_file_sl model.en-cs.en  --lm_file_tl model.en-cs.cs \
            --porn_removal_train porn-removal.txt.en  --porn_removal_file porn-model.en \
            -m training.en-cs.yaml \
  ```

  This will train an Extra Trees classifier for English-Czech using the corpus corpus.en-cs.train, the probabilistic dictionaries `dict-en-cs.gz` and `dict-cs-en.gz`, and the word frequency dictionaries `wordfreqs-en.gz` and `wordfreqs-cs.gz`.
  This training will use 50000 good and 50000 bad examples.
  The classifier data will be stored in `en-cs.classifier`, with the metadata in `training.en-cs.yaml`. The improved fluency language models will be `model.en-cs.en` and `model.en-cs.cs`, and the porn filter model will be `porn-model.en`.

  The generated .yaml file provides the following information, that is useful to get a sense on how good or bad was the training (and is also a needed input file for classifying):

  ```yml
  classifier: en-cs.classifier
  classifier_type: extra_trees
  source_lang: en
  target_lang: cs
  source_dictionary: dict-en-cs.gz
  target_dictionary: dict-cs-en.gz
  source_word_freqs: wordfreqs-en.gz
  target_word_freqs: wordfreqs-cs.gz
  normalize_by_length: True
  qmax_limit: 40
  disable_features_quest: True
  good_test_histogram: [0, 7, 39, 45, 112, 172, 514, 2199, 6912, 0]
  wrong_test_histogram: [14, 4548, 4551, 747, 118, 18, 3, 1, 0, 0]
  precision_histogram: [0.5000000, 0.5003502, 0.6475925, 0.9181810, 0.9860683, 0.9977594, 0.9995846, 0.9998903, 1.0000000, nan]
  recall_histogram: [1.0000000, 1.0000000, 0.9993000, 0.9954000, 0.9909000, 0.9797000, 0.9625000, 0.9111000, 0.6912000, 0.0000000]
  accuracy_histogram: [0.5000000, 0.5007000, 0.7277500, 0.9533500, 0.9884500, 0.9887500, 0.9810500, 0.9555000, 0.8456000, 0.5000000]
  length_ratio: 1.0111087
  features_version: 4
  source_lm: model.en-cs.en
  target_lm: model.en-cs.cs
  lm_type: CHARACTER
  clean_mean_perp: -1.0744755342473238
  clean_stddev_perp: 0.18368996884800565
  noisy_mean_perp: -3.655791900929066
  noisy_stddev_perp: 0.9989343799121657
  disable_lang_ident: False
  porn_removal_file: porn-model.en
  porn_removal_side: sl

  ```



  Although `bicleaner-train` and `bicleaner-classify` make use of parallelization by distributing workload to the available cores, some users might prefer to implement their own parallelization strategies. For that reason, single-thread version of Bicleaner classifier script is provided: `bicleaner-classify-lite`. The usage is exactly the same as for the full version, but omitting the blocksize (-b) and processes (-p) parameter.
  **Note**: `bicleaner-train-lite` was removed due to the lack of usage by the users and to avoid code duplication.

  ___

  ![Connecting Europe Facility](https://www.paracrawl.eu/images/logo_en_cef273x39.png)

  All documents and software contained in this repository reflect only the authors' view. The Innovation and Networks Executive Agency of the European Union is not responsible for any use that may be made of the information it contains.


