Saravanan666/pypi-org huggingface dataset:
Package: beard-portscan
PortScanPyPi Project: beard-portscan0.1.0: Initial Release after ForkOutputs a list of dictsInstall:pip install beard-portscanUpgrade:pip install beard-portscan --upgradeUsage:portscan [192.168.1.0/24] [-p 22,80-200 [-t 100 [-w 1 [-e]]]]Forked fromAperocky/PortScanAll Information below this line is from the original REPO.PortScan is alight-weightcommand line utility that allows user to conduct scanning over a range of IP addresses and port ranges with multi-threading.New in version 0.2.1:By default the command checks for yourLocal Area NetworkIP first, and then initiate a block wise search. specify IP if you want to search any other IP blocks.Note: This is not available before 0.2.1, please update or specify IP if you're using 0.2.0 and olderUse-w [float]to change timeout settings from default of3seconds: for LAN, this can be as low as0.1.1is usually good enough for continental level connection.Scanned 5000 ports in 2 secondsTo show more potential connection, use-e, this will show you all ports that are not timed out.Argumentsip: default and optional(since 0.2.1, required before 0.2.1)argument, can parse single IP, list of IP, IP blocks:192.168.1.0 # single IP

192.168.1.0/24 # A 24 block, from 192.168.1.0 to 192.168.1.255

[192.168.1.0/24,8.8.8.8] # The aforementioned 24 block and 8.8.8.8.

"[192.168.1.0/24, 8.8.8.8]" # if you want to use space in the command, wrap in quotes.Options:-p,--port: port range, default22,23,80, use,as a delimiter without space, support port range (e.g.22-100,5000).-t,--threadnum: thread numbers, default 500, as of now, thread number have a hard cap of 2048. More thread will increase performance on large scale scans.-e,--show_refused: show connection errors other than timeouts, e.g. connection refused, permission denied with errno number as they happen.-w,--wait: Wait time for socket to respond. If scanning LAN or relatively fast internet connection, this can be set to1or even0.2for faster scanning. Default3secondsAcknowledgementJamieson Becker: For coming up with a way to find local IP on stackoverflow, which I used:https://stackoverflow.com/questions/166506/finding-local-ip-addresses-using-pythons-stdlib
Package: bearer
Bearer PythonBearer Python clientInstallationpip install bearerUsageGet your BearerSecret Keyand integration id from
theDashboardand use the Bearer client as follows:Calling any APIsfrombearerimportBearerbearer=Bearer('BEARER_SECRET_KEY')# find it on https://app.bearer.sh/keysgithub=(bearer.integration('your integration id')# you'll find it on the Bearer dashboard https://app.bearer.sh.auth('your auth id')# Create an auth id for your integration via the dashboard)print(github.get('/repositories').json())We userequestsinternally and we
return the response from this library from the request methods (request,get,head,post,put,patch,delete).More advanced examples:# With query parametersprint(github.get('/repositories',query={'since':364}).json())# With body dataprint(github.post('/user/repos',body={'name':'Just setting up my Bearer.sh'}).json())Setting the request timeout, and other http client settingsBearer client is written on top of excellentrequestslibrary. Bearer provides reasonable defaults but you can adjust http client configuration by using any keyword argument which is accepted by requests.request method usinghttp_client_settingskeyword argument.
By default bearer client times out after 5 seconds. Bearer allows to increase the timeout to up to 30 secondsfrombearerimportBearerbearer=Bearer('BEARER_SECRET_KEY',http_client_settings={"timeout":10})# increase the request timeout to 10 seconds globally# you can specify client settings per integration as wellgithub=bearer.integration('github',http_client_settings={"timeout":2})# github api is super fast 2 seconds should be plentyprint(github.get('/user/repos'))Development# setup venv$python-mvenvvenv# install dependencies$venv/bin/pythonsetup.pydevelop# start the console$venv/bin/python
Package: bearer-agent
Bearer AgentObserve, control and receive alerts on your third-party APIs by adding theBearer agentto your Python application.DocumentationThe documentation is hosted athttps://python.docs.bearer.sh/InstallationThe Bearer agent requiresPython 3.x >= 3.5.Install from PyPI:$pipinstallbearer-agentThen set up the Bearer agent with your Secret Key (available on theBearer dashboard):importbearer_agentbearer_agent.init(secret_key="YOUR_BEARER_SECRET_KEY")Keeping your data protectedWe recommend you sanitize your data before sending it to the Bearer dashboard.
We think it's best to  setup the sanitization level that best suits your needs.
An example using the default values is as follows:bearer_agent.init(strip_sensitive_data=True,strip_sensitive_keys=("^authorization$|""^password$|""^secret$|""^passwd$|""^api.?key$|""^access.?token$|""^auth.?token$|""^credentials$|""^mysql_pwd$|""^stripetoken$|""^card.?number.?$|""^secret$|""^client.?id$|""^client.?secret$"),strip_sensitive_regex=(r"[a-zA-Z0-9]{1}[a-zA-Z0-9.!#$%&’*+=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*|"r"(?:\d[ -]*?){13,16}"))Compatibility matrixPython3 :On Python 3.x (>= 3.5) bearer support the following:http.clientfor Python >= 3.6urllib3:requestshttpcore>= 0.9 (both HTTP 1.1 and HTTP 2)httpx>= 0.12Twisted>= 19.2aiohttp>= 3.6.2On Python 2.7, bearer support the following client Library or application based on:httpliburllib3:requestsTwisted>= 19.2DevelopmentRunning testsTo run a format check (black), the linter (flake8) and tests (pytest):$toxTo only run the tests:$tox-epy37Git hooksThere are Git hooks to format the code and run the linter when committing.Installhttps://pre-commit.com/and then run:$pre-commitinstall
Package: bearface
:bear: bearface :bear:Overviewbearfaceis a library of customOmegaConfresolvers.
The resolvers can be easily registered in your python project by adding the following lines:frombearfaceimportregister_resolversregister_resolvers()DocumentationInstallationContributingAPI stabilityLicenseInstallationWe highly recommend installing
avirtual environment.bearfacecan be installed from pip using the following command:pipinstallbearfaceTo make the package as slim as possible, only the minimal packages required to usebearfaceare
installed.
To include all the packages, you can use the following command:pipinstallbearface[all]Please check theget started pageto see how to
install only some specific packages or other alternatives to install the library.ContributingPlease check the instructions inCONTRIBUTING.md.API stability:warning: Whilebearfaceis in development stage, no API is guaranteed to be stable from one
release to the next.
In fact, it is very likely that the API will change multiple times before a stable 1.0.0 release.
In practice, this means that upgradingbearfaceto a new version will possibly break any code that
was using the old version ofbearface.Licensebearfaceis licensed under BSD 3-Clause "New" or "Revised" license available inLICENSEfile.
Package: bearing
Starling BearingSpatial Python FrameworkReport a Bug|Request a Feature|Ask a Question|Make a Sugestion|Start a DiscussionTable of ContentsAboutQuick StartUsageAuthorsRoadmapLicenseContributingDisclaimerAboutStarling Bearingis a Spatial Python Framework.Quick Start...Usage...AuthorsStarling Bearingis an open-source project byStarling Associates.Starling is a spatial insight, strategy and design bureau that develops regenerative and lively environments with a net-positive impact on our future. We embrace the beautiful complexity of our planet’s ecosystems and use a systemic approach to sustainability, circularity and nature-inclusiveness. We go well beyond the life cycle of the places we design and aim to foster the cycle of life that flows through them. Therefore, we develop innovative instruments that are inspired by natural principles and allow us to generate a deep understanding of the environment. We utilise these constantly evolving insights to develop strategies and designs that serve people, society, economy and the ecologies in which they reside in harmony.website:www.starling.associatesRoadmapLicenseExcept where otherwise noted,Starling Bearingis licensed under the terms of theCreative Commons Attribution-ShareAlike 4.0 International License.ContributingWe'd love for you to contribute and to makeStarling Bearingeven better than it is today!
Please refer to thecontribution guidelinesfor information.DisclaimerTHIS SOFTWARE IS PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
Package: bearing-python
IntroductionThebearing-pythonis package which include common bearing fault diagnosis dataset implement in numpy, CWRU[1], Paderborn[2] and Jnu[3], etc., and will include more in the future. This package can be used toDeep Learning,Transfer LearningandSemi-Supervised Learning(domain adaptation), etc.. Original data comes from the official bearing vibration. The data is based on the original vibration data without repeated segmentation (the sampling window length is equal to hop length) and is provided in numpy.Array format.Although the original '*. mat' file of CWRU can be downloaded automatically at the first call , we still recommend you, for possible time consumption and transmission interruption, manually download the dataset file through the link below:CWRU:
Download Link：https://pan.xunlei.com/s/VNNBE0GiGHD5r5_l4BsYOTP-A1?pwd=3syk#Extraction Code：3sykPaderborn:
Download Link:https://www.aliyundrive.com/s/AanRmmBNZnaExtraction Code: 4qq9Jnu:
Download Link:https://pan.xunlei.com/s/VNNVrpOoaEAPPdIODQaJQQcQA1?pwd=jnri#Extraction Code: jnriYou may need to reorganize dir if you download CWRU from the official file by following format:Cwru
	12DriveEndFault
		1797
			12DriveEndFault
				1797	
					0.007-Ball.mat
					..........
			NormalBaseline
				1797
					.........
	12FanEndFault
		......
	48DriveEndFaultinstall packagepipinstallbearing-pyExampledatasetsimportbearingdataset=bearing.datasets.Cwru(exp='12DriveEndFault',rpm='1797',length=1024,root=r'.')print(dataset.x.shape,dataset.y.shape)print(type(dataset.x))cout>>:(2013,1024)(2013,)<class'numpy.ndarray'>transformimporttorchimportbearing.transformasTtransform=T.Compose(T.Normalization())x=torch.randn(1,1,1024)x_transform=transform(x)DeclarationOur code refers to [Litchiware/cwru (github.com)] and modifies a bit.for more details about each dataset please visit the following link:
[1] CWRU:https://engineering.case.edu/bearingdatacenter/download-data-file.
[2] Paderborn:https://mb.uni-paderborn.de/kat/forschung/datacenter/bearing-datacenter/[3] Jnu:
Package: bearlib
bearlibA simple collection of helper routines that I use in a lot of projects.NOTE: As of version 0.10 this is a Python 3 only moduleConfigA dictionary based config class:c = Config({ 'a': 1, 'b': 2, 'c': {'d': 1}}
print("c.a =", c.a)
print("c.c.d" =", c.c.d)generates:c.a = 1
c.c.d = 1It also has three helper methods:fromDict(dictionary)
fromJson(filename)
fromEtcd(host='127.0.0.1', port=4001, base='/')fromDict() walks thru the keys of the given dictionary recursively and adds them
to the object. Any key found that has a list or dictionary value is handled with
instances of Config created as needed.fromJson() uses json.load() to process the given filename and then calls fromDict()
to store the values.fromEtcd() walks the directory tree at the base location in the etcd server, builds
a dictionary and then passes that to fromDict() for storage.EventsRight now I’m going to use a very simple “plugin” style for event handlers where any .py file found in a directory is imported as a module.This will, I think, let me use the event plugins via the command line, but also via WebHooks because I can create a Flask listener for WebHook urls and then call the defined handler for a given event.Installfrom PyPI:pip install bearlibfrom git:cd /base/of/your/virtualenv
pip install -e git+https://github.com/bear/bearlib.git#egg=bearlibto update the from-git install:cd /base/of/your/virtualenv
pip install –upgrade -e git+https://github.com/bear/bearlib.git#egg=bearlibTestsFrom the source directory:make test
Package: bearlibterminal
ContentsAboutInstallationRequirementsLicenseAboutBearLibTerminal is a library that creates a terminal-like window facilitating
flexible textual output and uncomplicated input processing.A lot of roguelike games intentionally use asketic textual or pseudographic visual style.
However, native output via the command line interface ususally have a few annoying
shortcomings like low speed or palette and font restrictions. Using an extended
character set (several languages at once or complicated pseudographics) may also be tricky.
BearLibTerminal solves that by providing it’s own window with a grid of character cells
and simple yet powerful API for configuration and textual output.Online documentation:http://foo.wyrd.name/en:bearlibterminal:referenceSource code and issue tracker:https://bitbucket.org/cfyzium/bearlibterminalDiscussion forum:http://forums.roguetemple.com/index.php?topic=3896.0InstallationUse pip:pip install bearlibterminalThis will install everything necessary to use BearLibTerminal from Python, both the wrapper and the library binary.frombearlibterminalimportterminalterminal.open()terminal.printf(2,1,"Hello, world!")terminal.refresh()whileterminal.read()!=terminal.TK_CLOSE:passterminal.close()RequirementsPython 2.7+ or 3.xLicenseBearLibTerminal is distributed under the MIT license.
Package: bearparse
bearparseA custom argument parser for non-standard arguments. Useful for AppworxPurposeTo simplifyRequirementsPython 3.8+UsagefrombearparseimportArgument,ArgumentParser# Create the parserparser=ArgumentParser(description="Program Description")parser.add_argument(Argument(name="arg",description="First Argument"))parser.add_argument(Argument(name="arg2",description="Required Argument",required=True))# Parse from argvargs=parser.parse_args()print(args.parsed)
Package: bears
bearsis a light alternative to pandas. Its main goal is to provide a columnar dataframe.
Dataframe is a collection of columns. Each column is a numpy.ndarray.The difference from pandas is as follows:
- no fancy indexing
- no label index / no active column
- no implicit copy / expensive operationYou can
- add/remove a column in O(1)
- slice indexing / list indexing without copy
- transpose the columnar dataframe to get the record-wise list
Package: bearsql
bearsqlBearsql adds sql syntax on pandas dataframe. It uses duckdb to speedup the pandas processing and as the sql engineFree software: MIT licenseDocumentation:https://bearsql.readthedocs.io.Basic UsageTo use bearsql in a project:from bearsql import SqlContext
import pandas as pd

sc = SqlContext()
# The above statement will create duckdb instance in memory. Once the session ends, the database will be erased and not be persisted
# To persist the database, you can instantiate sqlcontext like:
# sc = SqlContext(database='<YOUR_DATABASE_NAME>.db'

df = pd.DataFrame([{'name': 'John Doe', 'city': 'New York', 'age': 24}, {'name': 'Jane Doe', 'city': 'Chicago', 'age': 27}])

# Create table from pandas dataframe
sc.register_table(df, 'testable') # <YOUR_TABLENAME> instead of 'testable'

# Query table and output to pandas dataframe
results = sc.sql('select * from testable', output='df')
output_df = next(results)
print(output_df)

# Query table and output to pyarrow table
results = sc.sql('select * from testable', output='arrow')
output_arrow_table = next(results)
print(output_arrow_table)

# Query table and output raw tuples
results = sc.sql('select * from testable', output='any')
output_rows = next(results)
print(output_rows)Create a relational table from dataframe and apply some operations:rel = sc.relation(df, 'new_relation') # <YOUR_RELATION_NAME> instead of new_relation

print(rel.filter('age > 24'))

# OR convert to df:

rel.filter('age > 24').df()Export the data to filesystem:result = sc.sql('EXPORT DATABASE \'<OUTPUT_FOLDER>\' (FORMAT PARQUET);') # format can either be PARQUET or CSV
list(result)For more examples, please visithttps://github.com/duckdb/duckdb/blob/master/examples/python/duckdb-python.pyFeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2021-06-30)First release on PyPI.
Package: bearychat
DocumentationRequirementsPython: 2.7/3.5requestsInstallationUse pip to install bearychat SDK.$ pip install bearychator for development:$ git clone https://github.com/bearyinnovative/bearychat.py.git
$ cd bearychat.py
$ python setup.py installExamplesIncomingfrombearychatimportincomingdefmain():data={"text":"hello, **world**","markdown":True,"notification":"Hello, BearyChat in Notification","channel":"testing"}resp=incoming.send("https://hook.bearychat.com/=bw52O/incoming/token",data)print(resp.status_code)print(resp.text)if__name__=="__main__":main()Real Time MessageBearyChat SDKDOES NOTprovide rtm loop, you should implement it with your
favorite websocket library.A reference implmenetation can be found atexamples/rtm_loop.pyDevelopmentOpenAPI Client Building$./scripts/gen_api.py>bearychat/openapi/_api.pyLicenseMIT
Package: bearychat-py
# bearychat-pyA simple package for interacting with [bearychat][bc]’s API.[bc]:http://bearychat.com[![Build Status](https://travis-ci.org/bcho/bearychat-py.svg)](https://travis-ci.org/bcho/bearychat-py)## Usage### Incoming Message`python >>> import bearychat >>>bearychat.Incoming('https://hook.bearychat.com').with_text('hello,world').push()`## Installation`bash pip installbearychat-py`## LICENSEMIT
Package: beast2bpp
The function beast2bpp.scan() converts a a starBeast input file in xml format to bpp format creating 3 files (a control file bpp.ctl, an individual map file bpp.Imap.txt, and a sequence data file bpp.txt). To execute the program use:import beast2bpp
beast2bpp.scan(‘input.xml’)where input.xml is the name of a starBeast xml file in the working directory (or the full path to the file).
Report and bugs tobrannala@ucdavis.edu
Package: beastiary
Beastiary is designed for visualising and analysing MCMC trace files generated from Bayesian phylogenetic analyses. Beastiary works in real-time and on remote servers (e.g. a HPC). The goal of Beastiary is to be a beautiful and simple yet powerful tool for Bayesian phylogenetic inference.Paper:Wirth & Duchene (2022)Documentation:https://beastiary.wytamma.comSource Code:https://github.com/Wytamma/beastiaryInstallpipinstallbeastiaryUseTo start beastiary use thebeastiarycommand.beastiaryFor more information read thedocs.CiteWytamma Wirth, Sebastian Duchene, Real-time and remote MCMC trace inspection with Beastiary, Molecular Biology and Evolution, 2022;, msac095,https://doi.org/10.1093/molbev/msac095
Package: beast-night-tv
JAK-Python-PackageNote:FormattingandTestingthe Code before Pushing is Important!!Go to thePackage,DocumentationInstallationWindowspipinstallbeast-night-tvLinuxpython3pipinstallbeast-night-tvMacOSpipinstallbeast-night-tvStepsClone the RepositoryIn a Directory open a Terminal and type:gitclonehttps://github.com/Jonak-Adipta-Kalita/JAK-Python-Package.gitInstalling The Required ModulesTo install the required modules, just open a terminal in the directory where this project is cloned. Now type:pipinstallvirtualenv
virtualenvvenv
.\venv\Scripts\activate
pipinstall-r.\requirements.txtand hit enter.Format CodeIn a terminal, type.\venv\Scripts\activate
black.
deactivateTestIn a terminal, type.\venv\Scripts\activate
pytest
deactivateand press Enter.Technology(s) UsedLanguage:PythonContributors
Package: beastxuserbot
py-Ultroid LibraryA stable userbot base library, based on Telethon.Installationpip install py-UltroidDocumentationUsage=> Create folders namedplugins,addons,assistantandresources.=> Add your plugins in thepluginsfolder and others accordingly.=> Create a.envfile withAPI_ID,API_HASH,SESSION,REDIS_URI&REDIS_PASSWORDas mandatory environment variables. Check.env.samplefor more details.=> Runpython -m pyBeastxto start the bot.Creating pluginsTo work everywhere@beastx_cmd(pattern="start",)asyncdef_(e):awaiteor(e,"Ultroid Started")To work only in groups@beastx_cmd(pattern="start",groups_only=True,)asyncdef_(e):awaiteor(e,"Ultroid Started")Assistant Plugins 👇@asst_cmd("start")asyncdef_(e):awaite.reply("Ultroid Started")Made with 💕 by@TeamUltroid.LicenseUltroid is licensed underGNU Affero General Public Licensev3 or later.CreditsLonamiforTelethon
Package: beasy
Simple BEA ClientInstallationpip install beasyDescriptionThis library is an unofficial Python API client forU.S Bureau of Economic AnalysisAPI.You can view the developer guide for the APIhere. This isnotthe user guide for this client library. However, it will provide useful information on how this library interacts with the API.PurposeOther BEA client libraries exist for accessing the API. However, in my opinion, they are either too complicated or poorly conceived. Therefore, this library is a simple and straightforward client.If complicated sorting, filtering, or formatting functions are desired, they will be added as utility functions that are not part of the client module.UsageCurrently, the library is designed to return JSON response objects from the BEA API, not XML.from beasy.beasy import Bea
API_KEY = 'your_api_key'
client = Bea(API_KEY)Get Dataset List"...retrieves a list of the datasets currently offered."client.getDatasetList()Get Parameter List"...retrieves a list of the parameters(required and optional) for a particular dataset."client.[table_name].getParameterList()client.Regional.getParameterList()Get Parameter Values"...retrieves a list of the valid values for a particular parameter."client.[table_name].getParameterValues(parameter)client.Regional.getParameterValues('LineCode')Get Parameter Values Filtered"...retrieves a list of the valid values for a particular parameter based on other provided parameters."client.[table_name].getParameterValuesFiltered(targetParameter, **kwargs)client.Regional.getParameterValuesFiltered('LineCode', 'SAINC1')Get Dataclient.[table_name].getData(**kwargs)client.Regional.getData(TableName='CAINC1', LineCode='3', GeoFIPS='DE', Year='2014')
Package: beat.backend.python
Python Backend for BEATThis package part ofBEAT, an open-source evaluation platform for data science
algorithms and workflows. It contains the minimum amount of code needed to run
user algorithms or inject data in toolchains from locally installed raw data
assets.InstallationComplete BEAT’sinstallationinstructions. Then, to install this package,
run:$ conda install beat.backend.pythonContactFor questions or reporting issues to this software package, contact our
developmentmailing list.
Package: beatboxtestbed
beatboxtestbedis the Background Error Analysis Testbed with Box Models.Documentationmaintained athttps://boxmodeling.meteo.physik.uni-muenchen.de/documentationInstallationpip install beatboxtestbedbeatboxtestbedneeds a number of other packages, all of them available through PyPi.
They should automatically be installed when using pip. Please read the installation
instructions of theboxmoxpackage, as they contain instructions on how to install
the underlying box model BOXMOX.beatboxtestbedrelies on 2 environmental variables to set the absolute path to work and
archive directories for beatbox experiments. You should add these directives to
your .bashrc, .profile (or similar, depending on your shell):export BEATBOX_WORK_PATH="/path/to/you/beatbox/work/directory"
export BEATBOX_ARCHIVE_PATH="/path/to/you/beatbox/archive/directory"Changelog1.0.0 (2017-12-19)Peer-reviewed version to be published in Knote et al., GMD0.1.0 (2017-08-12)Initial release
Package: beat.cmdline
Core Components for BEATThis package part ofBEAT, an open-source evaluation platform for data science
algorithms and workflows. It contains the command-line based program that can
download/upload components with the platform. It can also run experiments
locally.InstallationComplete BEAT’sinstallationinstructions. Then, to install this package,
run:$ conda install beat.cmdlineContactFor questions or reporting issues to this software package, contact our
developmentmailing list.