Saravanan666/pypi-org huggingface dataset:
Package: bordercontrol
.. image::https://travis-ci.com/hardenchant/nats_scan_wrapper.svg?token=oEYn8ZVFWCpj1fwzyy2Q&branch=master:target:https://travis-ci.com/hardenchant/nats_scan_wrapper:alt: Build status for the master branch.. image::https://img.shields.io/pypi/v/bordercontrol.svg:target:https://pypi.org/project/bordercontrol/:alt: Latest version on PyPiInstruction for develop a new module... code-block:: pythonfrom bc.dev.handlers import WorkerThreadHandler

counter = 0

def worker_function(data):
    global counter
    counter += 1
    print(counter)

    return {"results": [1, 2, 3, 45]}

a = WorkerThreadHandler(worker_function=worker_function, name='name', hostname='hostname')
a.run()worker_function- required argname- optionalhostname- optionaldata- here you see all data which send in sheduler in your channel, e.g.:.. code-block:: json{
   "_id":"5c4f3c5e1a169100074132ca",
   "pipeline":[
        "tgchecker"
   ],
   "crontab":"* * * * *",
   "payload":{
        "integram_url": "",
        "text": ""
   },
   "active": false,
   "trigger_timestamp": 1548696730,
   "full_pipeline":[
        "tgchecker"
   ]
}{"results": [1, 2, 3, 45]}- module send to channel_reporteras:.. code-block:: python{
    'task_data': data,
    'result': [1, 2, 3, 45],
    'name': 'name',
    'hostname': 'hostname'
}Module send to channel_registration:.. code-block:: json{
    "name": "name",
    "hostname": "hostname"
}Module must receive from channel_registration:.. code-block:: python{
    'subjects_to_subscribe': ['test'],
    'unique_name': 'test_module1'
}If error will be detected in worker, module send error message to channel_errors:.. code-block:: python{
    'task_data': data,
    'result': "ERROR",
    'name': 'name',
    'hostname': 'hostname'
}
Package: borderline
BorderlineStop letting modules reach into other modules.This library provides one thing and one thing only: a test class calledTestModuleImports.To use the test, subclass it in the test suite of the module you want to isolate and define that module's borderlines.
The test will fail if a module is not respecting those borderlines.For example, a module calledreport_buildercould have the following definition:classTestReportBuilder(ModuleImports):module="reporting.report_builder"# The public API of the module.# External modules should only import from here.public_submodules=("reporting.report_builder.api",)# Modules that are considered outside of `module` and should not be imported# by `module` unless they are a legitimate dependency.external_modules=("reporting",)# Modules outside of `module` that ARE legitimate dependencies.external_dependencies=("reporting.review.api","reporting.common",)# Directory to store imports that are currently allowed.# This is useful when you are trying to isolate an existing module# that is not respecting its borderlines.grandfather_filedir=Path("reporting/report_builder/tests/data/borderline",parents=True,exist_ok=True)
Package: bordr
bordrA pip installable version of RDRPOSTagger with Tibetan-specific changes.See the originalRDRPOSTaggerfor documentation.Check themodificationsimplemented in this repo.Seerdr-datafor RDR models for Tibetan.Seeusage.pyfor the programmatic interface available in bordrMaintenanceBuild the source dist:rm-rfdist/
python3setup.pycleansdistand upload on twine (version >=1.11.0) with:twineuploaddist/*Latest changeThe SDICT content passed to generate INIT file is changed.
The words in SDICT are given U(Unique tag from bilou tagging system) tag as those words are segmented as Unique token by botok.
With that changed SDICT content, we will get INIT file based on botok segmentation. Hence rules generated will be able to resolve botok segmentation ambiguity.
Package: boreal
BorealBokehReactiveAudio WidgetLibraryFree software: MIT licenseDocumentation:https://boreal.readthedocs.io.Boreal is a library for creating plots that react to audio while the
audio is playing. The reactive audio widgets can be used as part of a
stand-alone Bokeh application but the primary goal of the framework is
to support the exploratory coding process when using Jupyter notebooks
for audio research.The library is designed to be extensible and supports the addition of
new audio reactive widgets as well as audio processors that extract
information from the underlying audio signal. Playback controls can be
used to play, pause, and seek the underlying audio and associated
visuals.InstallationBuilding from sourceTo build boreal from source try:python setup.py buildThen to install:python setup.py installIf all went well, you should be able to run the following command in Python:import borealGet startedTo see how Boreal works try the following notebook (also part of the package):https://github.com/gtzan/boreal/blob/main/boreal/audio_widgets_notebook.ipynbFeaturesBokeh application for audio reactive plotsExample audio widgets: time domain, spectrum, waveform envelope, circularEQSupport for both real-time computation of visuals as well as pre-computationAbility to use html audio for playback on a local machine when notebook
is hosted remotelyStraighforward to add new audio widgets and audio processorsTODOBoreal is under development and there is a lot of additinal work planned.
Some examples include:More audio widgetsBetter documentationSupport for multi-channel audioCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2022-09-22)First release on PyPI.
Package: boreal-py
BOREAL pythonThis is python port ofboreal rust libwhich is a pure implementation ofYARAin rust.
It is a substitute for usingyara-python. As boreal is write in pure Rust we usematurin /pyo3to make a python wheel that does not need any special libs ot dynamic linking.using in pythonexample_conent_rule="""rule xxx_rule1{strings:$s1 = "hello"condition:filename endswith "test_file.txt" and $s1}"""deftest_scanner():yara=boreal_py.Yara()yara.add_rules_str(example_conent_rule)yara.define_symbol("filename","")scanner=yara.compile()results=scanner.scan_file("text.txt",{"filename":"text.txt"})local development and test$python3-mvenv.venv
$source.venv/bin/activate(.venv)$pipinstall-Upipmaturin(.venv)$pipfreezematurin==0.14.0tomli==2.0.1
$./test.sh
Package: borec-tool
BOREC tool is a python GUI-based tool for processing hyperspectral data.
It has functionality for reading and browsing data in ENVI file format.
It provides functions for evaluating statistics, clustering and denoising hyperspectral data.BOREC tool is Free, Open Source Software (FOSS) distributed under the BSD-3 License.Getting startedYou need to havePythonand thepip installatorinstalled on your system. We recommend to use theMinicondadistribution.The latest release of the tool is always hosted onPyPI.
You can install the BOREC tool and its dependences from the command line withpip install borec-toolFunding AcknowledgementTH03010330 BOREC – Barevný Obraz v prostředí „Realtime Embedded Computing“Technology Agency of the Czech Republic
Package: bored
Bored API WrapperUnoffical wrapper forhttps://www.boredapi.com/.UsageActivity ClassclassActivity:activity=""#stringaccessibility=0.0#floattype=""#stringparticipants=0#intprice=0.0#floatlink=""#stringkey=0#intGet a random eventgetRandomActivity()returnsActivityGet Activity From KeygetActivityFromKey(key)returnsActivityGet Activity From TypegetActivityFromKey(type)returnsActivityGet Activity From ParticipantsgetActivityFromKey(participants)returnsActivityGet Activity From PricegetActivityFromKey(price)returnsActivityGet Activity From Price RangegetActivityFromKey(min,max)returnsActivityGet Activity From AccessibilitygetActivityFromAccessibility(accessibility)returnsActivityGet Activity From Accessibility RangegetActivityFromAccessibility(min,max)returnsActivity
Package: bored-api
async-bored-apiThe unofficial async API wrapper forhttp://www.boredapi.com/Installingpip install --upgrade bored_apiUsageHere is simple example of usage.importasyncioimportbored_apiasyncdefmain():client=bored_api.BoredClient()activity=awaitclient.get_by_type(bored_api.ActivityType.BUSYWORK)print(activity.activity)asyncio.run(main())Documentation and API Reference:https://damego.gitbook.io/async-bored-api/
Package: bored-config-parser
Bored Config ParserThis is a small module you can use to make using config files easyExampleA config like this:general:name:"test"frequency:22targets:-name:"t1"size:"2G"-name:"t2"size:"1G"can be easily used with the following code:fromtypingimportListfromconfig_parserimportload_configclassGeneral:name:strfrequency:intclassTarget:name:strsize:str@load_config("path/to/config.yaml")classConfig:general:Generaltargets:List[Target]print(Config.general.name)fortargetinConfig.targets:print(target.name)
Package: borg2mqtt
Borg -> MQTTSend borgbackup updates over MQTT, including support for Home Assistant MQTT autodiscovery. Sensors includeTotal/unique chunks(Un)compressed sizeDepuplicated (Un)compressed sizeTotal number of backupsMost recent backupInstallationInstall on any system as python library usingpipinstallborg2mqttWhatever system it is installed on will need the ssh keys for your backup locations.Configurationborg2mqtt reads MQTT and repository information from a configuration yaml file. An example configuration file can be generated by runningborg2mqtt-cpath/config.ymlgenerateIf portionpath/config.ymlis left off, borg2mqtt defaults to saving/looking for the configuration file at$HOME/.config/borg2mqtt/config.yml.The configuration file is mostly self-explanatory and looks as follows:# -------------- Sample configuration file -------------- ## These are the default MQTT values - none are requiredmqtt:host:localhostport:1883user:""password:""# Put in as many repositories as desiredrepos:# Required-repo:user@address:/path/to/backup# Optional, defaults to the same as repo if not specified# This will be used to make entity_ids in HAname:Local Data# Optionalkey:""# Optional, choose one of kB, MB, GB, TB. Defaults to GB.units:GBUsageTo send the Home Assistant MQTT auto-discovery message, runborg2mqttsetupThen to update sensor information runborg2mqttupdateThis can be included in a cron job, borgmatic, etc to send updates as needed. As this is a "local push" option, it should be more efficient than any local polling option that could be included in Home Assistant.Additionally, a single repository can be updated through it's name found in the configuration file byborg2mqttupdate-n"My Repo"Additional OptionsAll options can always be shown by using flag--help. Additionally, varying levels of verbose output can be included through-vvv, put before the command type.ContributingAll pull requests are more than welcome. Please usse the pre-commit hooks to verify your code before making a pull request. If any bugs are found, feel free to open an issue with your verbose output (-vvv) included.
Package: borgini
ini config for borg backupA wrapper to quickly get you started backing up with borgAn easy to use ini style and profile based formatRequires:Python 3 >= 3.5.0, plus development headersOpenSSL >= 1.0.0, plus development headerslibacl (which depends on libattr), both plus development headersliblz4 >= 1.7.0 (r129)libzstd >= 1.3.0libb2For information on how to install these dependencies for Borg:https://borgbackup.readthedocs.io/en/stable/installation.htmlInitialize the config$borginiFirst run detected for profile: default
Make all necessary changes to config before running this again
You can do this by running the command:

. borgini EDITOR --config --select default

Default settings have been written to the ``include`` and ``exclude`` lists
These can be edited by running:

. borgini EDITOR --include --select default
. borgini EDITOR --exclude --select defaultNotethe--selectoptional argument does not need to be passed if using the default profileEdit the config$borginivim--configNoteThe selected editor is up to the userThe following would also work (provided they are installed)$borginicode--config$borginigedit--config$borgininotepad--configEnsure to make necessary changes to theDEFAULTsectionAnd ensure to configure theSSHsection if an ssh repo is configuredThe remaining configurations will suite most peopleIf you use theBORG_PASSPHRASEenvironment variable edit theENVIRONMENTsection to point to the keyfileNotethe file should contain one line and a password stored with safe read-write and ownership permissionsEdit the include and exclude files$borginivim--include# add a list of paths to back up$borginivim--exclude# add a list of paths to excludeNoteThe exclude list can contain subdirectories and files listed within the include listThis will override their inclusionTo switch between profiles add--selectPROFILE$borginivim--config# edit default config$borginivim--config--selectprofile2# edit profile2's config$borginivim--include--selectprofile2# edit profile2's include file$borginivim--exclude--selectprofile2# edit profile2's exclude file$borgini--selectprofile2# run profile2's backupAdd the following for nightly backups at 12:00 to your crontab$00***/usr/local/bin/borgini$00***/usr/local/bin/borgini-sprofile2# easy for multiple repos
Package: borg.localrole
OverviewA PAS plugin which can manage local roles via an adapter lookup on the current
context.Source CodeContributors please read the documentProcess for Plone core’s developmentSources are at thePlone code repository hosted at Github.Changelog3.1.11 (2023-10-07)Internal:Update configuration files.
[plone devs] (cfffba8c)3.1.10 (2023-02-22)Bug fixes:Add configuration with plone/meta.
[gforcada] (#1)3.1.9 (2022-11-14)Bug fixes:Add PEP 508 style requirements to not depend on Zope2 in Python 3. [jensens] (#12)3.1.8 (2020-04-20)Bug fixes:Minor packaging updates. (#1)3.1.7 (2020-03-21)Bug fixes:Minor packaging updates. [various] (#1)3.1.6 (2018-09-23)Bug fixes:Python 2 / 3 compatibility.
[ale-rt, pbauer]Fix issue StopIteration raising a Runtimeerror in Python 3.7
Seehttps://www.python.org/dev/peps/pep-0479/[pbauer]3.1.5 (2018-02-02)Bug fixes:ImportactivatePluginInterfacesfrom the canonical place inProducts.PlonePAS.
[maurits]Python 2 / 3 compat with six.
[jensens]Cleanup:No self-contained buildout,utf8-headers,isort,ZCA-decoratorsformatting/readability/pep8,Security decorators[jensens]Fix test for Zope 4.
[pbauer]3.1.4 (2017-10-17)Bug fixes:Made test compatible with zope4.  [pbauer]3.1.3 (2016-11-18)Bug fixes:Removed ZopeTestCase.  [maurits]3.1.2 (2016-08-17)Fixes:Use zope.interface decorator.
[gforcada]3.1.1 (2014-10-23)Ported tests to plone.app.testing
[tomgross]3.1 (2014-03-01)Moved portal_factory stuff to Products.ATContentTypes for PLIP #13770
[ale-rt]3.0.2 - 2010-10-27Close<input>tags properly (Chameleon compatibility).
[swampmonkey]3.0.1 - 2010-07-18Avoid raising deprecation warnings about our own code.
[hannosch]Use the standard libraries doctest module.
[hannosch]3.0 - 2010-07-01Update docstring. Nested groups do work properly.
[esteele]3.0a1 - 2009-11-17Avoid polluting test environment with extra adapter registrations.
[davisagli]UseTesting.ZopeTestCase.placelessinstead ofzope.app.testing.placeless.
[hannosch]Adjusted test setup for Plone 5.
[hannosch]Added thereplace_local_role_managermethod formerly found in CMFPlone.
[hannosch]Standardize package documentation and remove invalid license files.
[hannosch]Declare test dependencies in an extra and fixed deprecation warnings
for use of Globals.
[hannosch]2.0.2 - UnreleasedSpecify package dependencies.
[hannosch]2.0.1 - 2008-07-31Support caching of allowed local roles on the request.
[witsch]Renamed the default adapter to “default” so that people don’t
accidentally override it with an unnamed adapter. Overriding the default
should be possible, but is a marginal use case. If it’s overridden but
not replicated properly, all sorts of problems can result.
[optilude]Added exportimport.zcml which registers TitleOnlyExportImport for
WorkspaceLocalRoleManager; this allows local roles plug-in to be
imported and exported as part of a GenericSetup profile.
[rafrombrc]2.0.0 - 2008-04-20Baseline for Plone 3.1
Package: borgo
BorgoBorgo is anAPI+Appfor easily interfacing with your python scripts.If your script needs human input, create a borgo request, and it will be sent to your mobile app. Your script will wait until you act on the request, and then continue with the results.For example:fromborgoimport*borgo_key='''eyJhbGciOiJSUzI1NiIsIOTYwYjA1Yzk3ZmE0MDljNDdhNDQ0ZTciLCZXRva2VuLmdvb2dsZSyZ28...'''withBorgoClient(borgo_key)asborgo_client:request=BorgoRequest('Should I tweet "hello world"?','Tweet',"Don't tweet")response=borgo_client.wait_for(request)if(response.is_accepted):# Send "hello world" to Twitter API.Getting a KeyTo get a key to pass into theBorgoClient(...)constructor, sign in toborgo.app, click on the "key" icon, hit the button to copy the key to your clipboard and then paste it as a string into your script.CommunityFor questions and discussion about Borgo, visitreddit.com/r/borgo
Package: borg_pod
# borg_pod Python design pattern and module.The Borg Pod pattern provides an easy method for creating dynamic and decoupled classes. Instead of imposing developer
overhead of linking class implementations, designing a state machine, referring to the correct pointers for the owners
of each attribute / method, and debugging the system - you could just put a wrapper above your classes and be done with
it.## GetClone this repo, or use pip3 install borg_pod## UseAt the top of your module, be sure to include:from borg_pod import resist, assimilate, BorgPodOr, if you adhere to Google standards:import borg_pod as bp_or_be_oilYou’ve imported borg_pod’s relevant attributes directly like a sane person?  Let’s say you have some classes you want
to be able to switch an instance between:class SomeClassA(object):def __init__(self):passdef my_method(self):print(“I AM SOME CLASS A”)class OtherClassB(object):def __init__(self):print(“HOLD ON, I AIN’T SO QUIET.”)def my_method(self):print(”…where am I again?”)def a_unique_method(self, to_print):print(to_print)All you would do is add the @assimilate decorator above both:@my_library.assimilate
class SomeClassA
…@my_library.assimilate
class OtherClassB…Creating and converting an instance of one would look like:my_first_unique = SomeClassA()my_second_unique = SomeClassA()my_third_unique = OtherClassB()assert my_first_unique is not my_second_unique and my_third_unique is not my_first_uniquefirst_b = SomeClassB(my_first_unique)second_b = SomeClassB(my_second_unique)third_b = SomeClassB(my_third_unique)assert (first_b is my_first_unique and second_b is my_second_unique and third_b is my_third_uniqueand first_b is not third_b and first_b is not second_b)And that’s it! More advanced usage involves the @resist decorator, to avoid the self reference injection - but most
devs don’t need to worry about that. You can find more thorough documentation inside of the module. Classes with
the @assimilate decorator can be subclassed and can be subclasses of other decorated or non-decorated classes.## Copyrightborg_pod module by Andrew M. Hogan. (borg_pod &copy; 2018 Hogan Consulting Group)## LicenseLicensed under the Apache License.
Package: borgssh
Project borgsshThis package simplifies theborgbackupuse with a ssh server
on a (remote) computer.UsageNAME
    sshborg

SYNOPSIS
    sshborg COMMAND

COMMANDS
    COMMAND is one of the following:

     list
       FIRST of the global commands: borg list ssh://borg@***:2222/config/borg

     create_and_prune_defaults
       SECOND of the global commands, use: sshborg create_and_prune_defaults --configfile ~/.borgssh.conf

     check
       borg check --info ssh://borg@***:2222/config/borg borg info ssh://borg@***:2222/config/borg

     create
       borg create ssh://borg@***:2222/config/borg::host_folder

     extract
       borg extract --dry-run --list ssh://borg@***:2222/config/borg::host_folder_***Remarksport 2222 is hardcodedusername borg is hardcodedprune is hardcoded (7 days, some weeks (8?), every month)ConfigurationThe config is in~/.borgssh.confby default, but can be in another file
and sshborg is run with-c configfileoption.The example of the config:{
"config": "~/.borgssh.conf",
"remote": "192.168.0.200",
"default_folders": [
 "~/x_Lectures",
 "~/x_DATA_ANALYSIS"
],
"quit": false
}ServerIn general, it is ok to use a prepared docker with ssh server:docker run -d  --name=openssh-server   --hostname=openssh-server  -e  PUID=1000   -e PGID=1000   -e TZ=Europe/London     -e SUDO_ACCESS=true   -e PASSWORD_ACCESS=true   -e USER_PASSWORD=mysecretpassword   -e USER_NAME=borg   -p 2222:2222   -v /media/raiddisks:/config   --restart unless-stopped   ghcr.io/linuxserver/openssh-serverand install borgbackup inside.ssh borg@127.0.0.1 -p 2222
sudo borg
apk update && apk add borgbackup --upgradethencommit the docker with a new name likeopenssh-server-borg, setup
theauthorized_keysto restrict sshcommand="/usr/bin/borg serve --restrict-to-path /config/borg" ssh-rsa AAAAB @gigaand the final docker can be run...docker run -d  --name=openssh-server-borg   --hostname=openssh-server-borg  -e  PUID=1000   -e PGID=1000   -e TZ=Europe/London    -e SUDO_ACCESS=false   -e PASSWORD_ACCESS=false   -e USER_PASSWORD=mysecretpassword   -e USER_NAME=borg   -p 2222:2222   -v /mnt/raiddisks/borgssh:/config   --restart unless-stopped   openssh-server-borgBorgbackup must be probably init-ed like:borg init ssh://borg@127.0.0.1:2222/config/borg -e nonegitlab:https://gitlab.com/jaromrax/sshborg
Package: borg.supergroup
Introduction============This is a PAS plugin that makes it possible to create groups "on the fly" forusers via subscription adapters and utilities.The plugin can be installed using a GenericSetup extension profile.For example, say you have an LDAP repository where a user property contains auser's business unit. If this is mapped as a user property, you can write asubscription adapter that adapts the user to ISuperGroups. It would look upthis property on a user and return a list of group ids that corresponds to thevalue of the property. When Plone lists a user's groups or assigns roles basedon a user's groups, the user will appear to be a member of this group.For example::from zope.interface import implementsfrom zope.component import adaptsfrom borg.supergroup.interfaces import ISuperGroupsfrom Products.PluggableAuthService.interfaces.authservice import IBasicUserclass ImpliedGroups(object):implements(ISuperGroups)adapts(IBasicUser)def __init__(self, context):self.principal = contextdef __call__(self):implied = self.principal.getProperty('implied_group', '')if implied:yield impliedThis can be registered in ZCML with::<subscriber factory=".groups.ImpliedGroups" />This is a simple example that looks for an implied group in the'implied_groups' user property. Of course, you could source the group(s) fromwherever you want. The return value should be an iterable (here we use agenerator).To make implied groups show up in general group listings (e.g. on the'Sharing' tab in the Plone user interface), you could write a named utilityproviding ISuperGroupsEnumeration. This will be passed some search parameters,and should return any implied groups if they can be matched to the searchparameters.For example::from zope.interface import implementsfrom zope.component import adaptsfrom borg.supergroup.interfaces import ISuperGroupsEnumerationclass ImpliedGroupsEnumeration(object):implements(ISuperGroupsEnumeration)def enumerate_groups(self, id=None, exact_match=False, **kw):if (exact_match and id == 'Alpha') or (not exact_match and id in 'Alpha'):yield dict(id='Alpha', title='Alpha Group')In ZCML, this would be registered with::<utilityfactory=".groups.ImpliedGroupsEnumeration"name="my.implied.groups"/>For more examples, see the tests in integration.txt and the interfacedeclarations in interfaces.py.Changelog=========1.0b1 - Unreleased----------------* Initial release