package
stringlengths 1
122
| pacakge-description
stringlengths 0
1.3M
|
|---|---|
abbreviation-uhh-what-is-word-for-tearing-apart-an-abbreviation | abbreviation-uhh-what-is-word-for-tearing-apart-an-abbreviationor auwiwftaaai swear dont lookpleasei just made this for my friend |
abbreviator | AbbreviatorPython Package to Abbreviate (product) names, using hyphenation provided by thepyphenpackage.Installationpip install abbreviatorExample Usageimport abbreviator
abbreviator.sentence_shortener('what fantastic') |
abbrey | Abbreivation decoderIt's not really smart, but extremely simple.
Example:from abbrey import AbbrDecoder
decoder = AbbrDecoder()
input_string = "He is a good pm"
print(decoder.decode_sentence(input_string))Output:He is a good project manager |
abbrfix | abbrfixLibrary for expanding and collapsing abbreviations commonly used in online communication.InstallationTo install the library, use pip:pipinstallabbrfixAlternatively, install the latest directly from the GitHub repository:pipinstallgit+https://github.com/dsymbol/abbrfix.gitUsageExpandfromabbrfiximportexpand_all,expand_one# Example text with abbreviationstext="I'll brb, gtg for lunch, ttyl!"# Expand all abbreviations in the textexpanded_text=expand_all(text)print(expanded_text)# Output: "I'll be right back, got to go for lunch, talk to you later!"# Expand a specific abbreviationexpanded_text=expand_one(text,"brb")print(expanded_text)# Output: "I'll be right back, gtg for lunch, ttyl!"Collapsefromabbrfiximportcollapse_all,collapse_one# Example text with expanded abbreviationstext="I'll be right back, got to go for lunch, talk to you later!"# Collapse all abbreviations in the textcollapsed_text=collapse_all(text)print(collapsed_text)# Output: "I'll brb, gtg for lunch, ttyl!"# Collapse a specific full formcollapsed_text=collapse_one(text,"talk to you later")print(collapsed_text)# Output: "I'll be right back, got to go for lunch, ttyl!"Update and Remove Abbreviationsfromabbrfiximportupdate_abbreviations,remove_abbreviations# Update the abbreviations dictionary with more abbreviationsnew_abbreviations={"lol":"laughing out loud","omg":"oh my god"}update_abbreviations(new_abbreviations)# Remove abbreviations from the dictionaryabbreviations_to_remove=["brb","gtg"]remove_abbreviations(abbreviations_to_remove) |
abb-robot-client | abb_robot_clientPython package providing clients for ABB robots using RWS (Robot Web Services) and Externally Guided Motion (EGM).
This package currently supports IRC5 controllers running RobotWare 6.xx. It does not support RobotWare 7+.This package is typically used withabb-motion-program-exec,
which provides a higher level interface to generate motion programs.abb-motion-program-execincludes the ability
to initialize EGM operations, using this package to communicate with EGM.abb_robot_clientincludes three modules:rws,rws_aio, andegm.rwsprovides a synhronous client for Robot
Web Services (RWS) using HTTP REST, and the ability to create subscriptions using websockets.rws_aioprovides
identical functionality torws, but uses asyncio, with each method beingasync.egmprovides an Externally
Guided Motion (EGM) client.Documentation can be found at:https://abb_robot_client.readthedocs.orgInstallationabb-robot-clientis avaliable on PyPi. Use the[aio]option to include support for asyncio:pip install abb-robot-client[aio]ExamplesSee theexamples/directory for examples using the modules.LicenseApache 2.0AcknowledgmentThis work was supported in part by Subaward No. ARM-TEC-21-02-F19 from the Advanced Robotics for Manufacturing ("ARM") Institute under Agreement Number W911NF-17-3-0004 sponsored by the Office of the Secretary of Defense. ARM Project Management was provided by Christopher Adams. The views and conclusions contained in this document are those of the authors and should not be interpreted as representing the official policies, either expressed or implied, of either ARM or the Office of the Secretary of Defense of the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for Government purposes, notwithstanding any copyright notation herein.This work was supported in part by the New York State Empire State Development Division of Science, Technology and Innovation (NYSTAR) under contract C160142. |
abb-robotraconteur-driver-hmp | ABB Robot Raconteur Driver Hybrid Motion Program (HMP)The ABB Robot Raconteur Driver Hybrid Motion Program (HMP) is a sophisticated driver capable of controlling an ABB
IRC5 based robot using either streaming commands using Externally Guided Motion (EGM), or through "Motion Programs".
Motion programs are sequences of commands that are uploaded to the ABB robot controller, and executed using the
motion computer. These motion programs usually consist of MoveAbsJ, MoveJ, MoveL, MoveC, and various other motion
primitive commands. The HMP driver is capable of automatically switching between these modes.The HMP driver implements three major robot interface types:com.robotraconteur.robotics.robot.Robot- The "standard robot" type for Robot Raconteur. This robot type uses
streaming position commands through EGM, and supports 3 command modes:jog,trajectory_command, andposition_command. In these modes, the HMP driver is fully compatibly with clients expecting a standard
Robot RaconteurRobotdriver.experimental.robotics.motion_program.MotionProgramRobot-MotionProgramRobotis a candidate new standard type
for robots that support motion programs. Many robot controllers do not have a streaming command interface, and are
limited to executing scripted motion programs. TheMotionProgramRobotand enclosing service type are designed
for these motion program only drivers. In the future, this service type will be included in the standard service
definitions.experimental.abb_robot.ABBRobot- TheABBRobottype implements bothRobotandMotionProgramRobot, allowing
clients to use either interface. In the future aHybridCommandRobotstandard type will also be considered. TheABBRobotobject type also provides proprietary support such as wires to send commands to EGM.Theexperimental.abb_robot.motion_programservice definition contains ABB proprietary motion primitive commands.The HMP driver is based on several Python packages:RobotRaconteur,RobotRaconteurCompanion,abb-robot-client,abb-motion-program-exec,robotraconteur-abstract-robot.InstallationThe driver can be installed using pip:pip install abb-robotraconteur-driver-hmpA robot info file is also necessary. These can be found in theconfig/directory of the GitHub repository. These
files contain metadata and kinematic information about the robot. The robot info file must match the model of the robot.
Open a discussion if your robot does not have a robot info file.The HMP driver uses the RAPID software from theabb-motion-program-execpackage
(https://github.com/rpiRobotics/abb_motion_program_exec). The repository contains detailed instructions on
how to install the robot software.EGM is required, and the EGM configuration must be used when the robot
is configured.Currently the HMP driver requires version 0.6.0 of the RAPID software, but this may increase
depending on the version ofabb-motion-program-execinstalled by pip.Once theabb-motion-program-execrobot software is installed, there are additional steps required:Edit theT_ROB1/motion_program_execRAPID module. This can be done in Robot Studio on the RAPID page, selectingRAPID/T_ROB1/motion_program_execunder the controller on the left pane tree. Modify theMOTION_PROGRAM_DRIVER_MODEline to showCONST num MOTION_PROGRAM_DRIVER_MODE:=1. This will enable the
operation for drivers.Set the "Run Mode" to "Continuous"Restart the controller. At this point, the controller should be ready.Running the driverFirst, start the controller. In auto mode, this is done by pressing "Reset PP to Main", and then pressing "Play".Next, start the driver:python -m abb_robotraconteur_driver_hmp --robot-info=config/abb_1200_5_90_robot_default_config.ymlReplace the filename specified for--robot-info=with the path to the robot info file for your robot.Using the driverThe driver creates a Robot Raconteur service that clients connect to command the robot. See theexamples/folder
for examples using the driver. Also Seehttps://github.com/robotraconteur/robotraconteurfor more information on
Robot Raconteur and how to communicate with the service.ExamplesSeveral example clients are provided in theexamples/directory demonstrating how to operate the robot in
different command modes:examples/abb_hmp_rr_client_jog.py- Client demonstrating usingjogcommand mode. Robot must be in manual mode.examples/abb_hmp_rr_client_egm_trajectory_control.py- Client demonstratingtrajectorycommand mode, which
uses EGM to command the robot to follow a prepared dense joint waypoint trajectory.examples/abb_hmp_rr_client_position_control.py- Client demonstratingposition_commandcommand mode, which passes
streaming joint position commands from the client to the robot controller using EGM.examples/abb_hmp_rr_motion_program.py- Client demonstratingmotion_programcommand mode, sending a sequence of
motion primitives to the robot controller.examples/abb_hmp_rr_motion_program_freeform.py- Client demonstratingmotion_programcommand mode, sending a
sequence of motion primitives to the robot controller usingFreeformCommandstructures.examples/abb_hmp_rr_client_motion_program_preempt.py- Client demonstrationmotion_programcommand mode preempting
the executing of a motion program sequence with updated commands.examples/abb_hmp_rr_client_motion_program_egm_joint.pyClient demonstratingmotion_programcommand mode
with ABB proprietary EGM joint control commands.examples/abb_hmp_rr_client_motion_program_egm_pose.pyClient demonstratingmotion_programcommand mode
with ABB proprietary EGM pose control commands.examples/abb_hmp_rr_client_motion_program_egm_correction.pyClient demonstratingmotion_programcommand mode
with ABB proprietary EGM path correction commands.LicenseApache 2.0AcknowledgmentThis work was supported in part by Subaward No. ARM-TEC-21-02-F19 from the Advanced Robotics for Manufacturing ("ARM") Institute under Agreement Number W911NF-17-3-0004 sponsored by the Office of the Secretary of Defense. ARM Project Management was provided by Christopher Adams. The views and conclusions contained in this document are those of the authors and should not be interpreted as representing the official policies, either expressed or implied, of either ARM or the Office of the Secretary of Defense of the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for Government purposes, notwithstanding any copyright notation herein.This work was supported in part by the New York State Empire State Development Division of Science, Technology and Innovation (NYSTAR) under contract C160142. |
abbrs | abbrsAbbreviationsInstall with:pip install abbrsabbrs/__init__.py:defread_file(filename):withopen(filename,encoding='utf-8')asf:returnf.read()defwrite_file(filename,s):withopen(filename,'w',encoding='utf-8')asf:f.write(s)defrm_hyphen_rf(path):importshutiltry:shutil.rmtree(path)exceptFileNotFoundError:passdefhash(x):fromzlibimportcrc32returncrc32(bytes(str(x),encoding='utf-8'))defcool_hash(x):returnhex(hash(x)).strip('0x')defhash_dir(x,hash=hash):return{i:hash(x.__getattribute__(i))foriindir(x)}# if '_' not in i }defget_time_str(fmt='%c'):importtimereturntime.strftime(fmt)defget_yyyymmdd_time_str():importtimereturnget_time_str('%Y-%m-%d%H-%M-%S')defjson_dump(filename,a):importjsondat=json.dumps(a,ensure_ascii=False,indent='\t')# so that json.decoder.JSONDecodeError won't damage the destination filewithopen(filename,'w',encoding='utf-8')asf:f.write(dat)# json.dump(a, f, ensure_ascii=False, indent='\t')dump_json=json_dumpdefload_json(filename):importjsonwithopen(filename,encoding='utf-8')asf:returnjson.load(f)defprepare_list(l):ifisinstance(l,str):l=l.strip().split()returnldefpack_dict(self,lst):lst=prepare_list(lst)return{i:self.__dict__[i]foriinlst}defload_helper(self,lst,loadfx):lst=prepare_list(lst)foriinlst:self.__dict__[i]=loadfx(i)defcurrent_path():importos.pathreturnos.path.basename(os.getcwd())defnext_version(version_file='version.txt'):SEPARATOR='\n'# style: 'x\nx\nx', without suffixes like 'b1', 'a2'version=read_file(version_file).strip().split(SEPARATOR)iflen(version)!=3:raiseTypeError(version)version=[int(i)foriinversion]version[2]+=1write_file(version_file,SEPARATOR.join(map(str,version)))return'.'.join(map(str,version))defpypi_setup(description,long_description_body,author='YAN Hui Hang, GDUFS',author_email='[email protected]',github_prefix='https://gitee.com/yanhuihang/',install=False):importsetuptools,sys,ospackage_name=current_path()long_description=f'''#{package_name}{description}Install with: `pip install{package_name}`{long_description_body}'''write_file("README.md",long_description)# sys.argv.extend('sdist bdist_wheel'.split())sys.argv.append('bdist_wheel')rm_hyphen_rf('dist')setuptools.setup(name=package_name,version=next_version(),author=author,author_email=author_email,description=description,long_description=long_description,long_description_content_type="text/markdown",url=github_prefix+package_name,packages=setuptools.find_packages(),classifiers=["Programming Language :: Python :: 3",# "License :: OSI Approved :: MIT License","Operating System :: OS Independent",],python_requires='>=3.6',entry_points={'console_scripts':[f'{package_name}={package_name}:main'],}ifinstallelse{})os.system('python -m twine upload dist/*')DEFAULT_SHELVE_FILENAME='shelve.out'DEFAULT_ENV_VARIABLE_STOPWORDS='__builtin__ __builtins__ exit get_ipython json np quit shelve time'.split()# __builtins__, my_shelf, modules, etc. can not be shelved.defshelve_restore(globals,filename=DEFAULT_SHELVE_FILENAME):# call with globals()importshelve# WARNING: default open mode of shelve is not 'r', but 'c'# (read & write, create if not present)withshelve.open(filename,'r')asmy_shelf:forkeyinmy_shelf:try:print("'{}'".format(key))globals[key]=my_shelf[key]except:print('ERROR shelving:{0}'.format(key))raise# call with dir()defsave_shelve(dir,globals,filename=DEFAULT_SHELVE_FILENAME,stopwords=DEFAULT_ENV_VARIABLE_STOPWORDS):importshelvewithshelve.open(filename,'n')asmy_shelf:# 'n' for newforkeyindir:try:my_shelf[key]=globals[key]# print('Shelving {} success'.format(key))# except:exceptTypeError:ifkeynotinstopwords:print('ERROR shelving:{0}'.format(key))defsuspend_file(path):importossuffix='.'+get_yyyymmdd_time_str()path2=path+suffixifos.path.exists(path2):suffix2=cool_hash(path2)whileTrue:path3=path2+'.'+suffix2ifos.path.exists(path3):suffix2=cool_hash(path3)else:path2=path3breakos.rename(path,path2)deftable(header,dat):fromprettytableimportPrettyTablex=PrettyTable()x.field_names=['Index']+headerc=1foriindat:x.add_row([c]+i)c+=1returnx |
abbts-blp | Github:https://github.com/p-d-h/abbts_blpInstallation: pip install abbts_blp (https://pypi.org/project/abbts-blp/)Dokumentation:https://raw.githack.com/p-d-h/abbts_blp/main/docs/build/html/index.html |
abby | abbyA/B testing for HumanAbby is a A/B testing library package for human. Abby aims to make A/B testing as easy as ABC and accessible to anyone.Installation$pipinstallabbyQuick StartPlease note that your variant name column should be named asvariant_name. Otherwise, the method will raise an error and ask you to adjust the column name accordingly.A/B testing for continuous metricfromabby.datasetsimportload_datasetfromabbyimportcompare_ttestdata=load_dataset('click_impression')compare_ttest(data=data,variants=['control','experiment'],numerator='click')A/B testing for ratio metricfromabby.datasetsimportload_datasetfromabbyimportcompare_deltadata=load_dataset("click_impression")compare_delta(data=data,variants=["control","experiment"],numerator="click",denominator="impression",)A/B testing for ratio metric using bootstrapfromabby.datasetsimportload_datasetfromabbyimportcompare_bootstrap_deltadata=load_dataset("click_impression")compare_bootstrap_delta(data=data,variants=["control","experiment"],numerator="click",denominator="impression",n_bootstrap=10_000,)A/B testing for multiple metricsfromabby.datasetsimportload_datasetfromabbyimportcompare_multiple,Ratiodata=load_dataset("click_impression")result=compare_multiple(data=data,variants=["control","experiment"],metrics=["click",Ratio("click","impression")],)A/B/N testing for multiple metricsfromabby.datasetsimportload_datasetfromabbyimportcompare_multiple,Ratiodata=load_dataset("click_impression_3_variants")result=compare_multiple(data=data,variants=["control","experiment_A","experiment_B"],metrics=["click",Ratio("click","impression")],) |
abbyInPython | No description available on PyPI. |
abbyPython | No description available on PyPI. |
a-b-c | soon |
abc-0329 | No description available on PyPI. |
abc-0329-linux | No description available on PyPI. |
abc1 | UNKNOWN |
abc123 | No description available on PyPI. |
abc1234 | No description available on PyPI. |
abc12345 | No description available on PyPI. |
abc123abc | No description available on PyPI. |
abcai | Principles Of AI LabProject on GithubTo Run the moduefromabcaiimportrunrun()List of AI Lab ExercisesBreadth-First Search (BFS)Depth-First Search (DFS)A* AlgorithmCrypto-Arithmetic ProblemsPredicate LogicSemantic NetworkNaive BayesGame PlayingMin-MaxAlpha-Beta PruningNLP: TokenizationSpell CheckingExpert System |
ab_calc | UNKNOWN |
abc_algorithm | No description available on PyPI. |
abc-analysis | Performs and visualizes an ABC analysis with automated limit detection.This package is a Python implementation of the R packageABCanalysis.The package is based on “Computed ABC Analysis for rational Selection of most informative Variables in multivariate Data”, PLoS One. Ultsch. A., Lotsch J. (2015)doi:10.1371/journal.pone.0129767.Basic Usagefromabc_analysisimportabc_analysis,abc_plot# Perform an ABC analysis on a numeric vector (without plotting)dctAnalysis=abc_analysis([1,15,25,17,2,3,5,6,2,3,22])# Perform an ABC analysis with plottingdctAnalysis=abc_analysis([1,15,25,17,2,3,5,6,2,3,22],True)# Plot saved results of an ABC analysisabc_plot(dctAnalysis) |
abc-annMacroF1withCost | ARTIFICIAL BEE COLONY ALGORITHM WITH LOGISTIC REGRESSION (ABC-LR)ABC-LR is a binary classification method in which the ABC algorithm is used instead of the Gradient Descent algorithm to train the weights in the Logistic Regression classification model. The purpose of the ABC algorithm in the ABC-LR method is to minimize the value of the cost function. The ABC algorithm is a very popular metaheuristic method that can search for solutions both locally and globally in the solution space. In addition, it has been shown in the study that the ABC-LR classification method achieves superior classification success compared to the LR classification method.Although the ABC-LR classification method can handle complex and high-dimensional data, its runtime can be high. Therefore, CPU and GPU parallelized versions of the ABC-LR classification method are presented here, and significant improvements in runtime can be achieved.ABC-LR is written in Python3 and continuously tested with Python 3.7 and 3.10.InstallationInstall ABC-LR via PyPI:pip install abcLROr alternatively, clone the environment:git clone https://github.com/kagandedeturk/ABC-LR.gitCPU Version UsageimportnumpyasnpparallelType=npfromabcLRimportABC_LR_Modelfromsklearn.datasetsimportload_breast_cancerX,y=load_breast_cancer(return_X_y=True)y=y.reshape(-1,1)lb=-16ub=16evaluationNumber=80000# FVS = trainData.shape[1]limit=50P=60MR=0.3L2=0model=ABC_LR_Model(lb=lb,ub=ub,evaluationNumber=evaluationNumber,limit=limit,P=P,MR=MR,L2=L2,parallelType=parallelType)#start_time = dt.datetime.now()model.fit(X,y)#print(f"Run time: {dt.datetime.now()-start_time}")print(f"Result:{model.score(X,y)}")GPU Version UsageimportcupyascpparallelType=cpfromabcLRimportABC_LR_Modelfromsklearn.datasetsimportload_breast_cancerX,y=load_breast_cancer(return_X_y=True)X=parallelType.array(X)y=parallelType.array(y.reshape(-1,1))lb=-16ub=16evaluationNumber=80000# FVS = trainData.shape[1]limit=50P=60MR=0.3L2=0model=ABC_LR_Model(lb=lb,ub=ub,evaluationNumber=evaluationNumber,limit=limit,P=P,MR=MR,L2=L2,parallelType=parallelType)#start_time = dt.datetime.now()model.fit(X,y)#print(f"Run time: {dt.datetime.now()-start_time}")print(f"Result:{model.score(X,y)}")LicenseThis program is free software: you can redistribute it and/or modify
it under the terms of the 3-clause BSD license (please see the LICENSE file).This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.You should have received a copy of the 3-clause BSD license
along with this program (see LICENSE file).
If not, seehere.Copyright (c) 2022, Bilge Kagan Dedeturk ([email protected]) |
abcattrs | abcattrsAbstract class attributes for ABCs.importabcfromabcattrsimportabstractattrs,Abstract@abstractattrsclassA(abc.ABC):foo:Abstract[int]# Abstract subclasses can add more required attributes@abstractattrsclassB(A,abc.ABC):bar:Abstract[str]classC(B):# C must define both of these attributes to not raise an errorfoo=1bar="str"TheAbstractqualifier can be combined with other PEP 593 annotations.fromtypingimportAnnotatedimportabcfromabcattrsimportabstractattrs,Abstract@abstractattrsclassA(abc.ABC):# Combine with other annotationsbar:Annotated[str,Abstract,"other info"] |
abc-classification | ABC classification libraryABC classification is an inventory categorisation technique. A typical example of ABC classification is the segmentation of products (entity) based on sales (value). The best-selling products that contribute to up to 70% of the total sales belong to cluster A. The products making up the next 20% of sales are in cluster B, whereas the products representing the last 10% of sales, belong to class C. Hence, the pattern is named after the three clusters (ABC).ExampleInstallationpip install abc-classificationImportfrom abc_classification.abc_classifier import ABCClassifierLet's say we have dataframeproducttotal soldfade cream27000powders24000shadows18000mascara16000lipstick6000concealer5000sculptors4000You can create ABCClasifier object, pass your dataframe
to it and call classify method.abc_clf = ABCClassifier(df)
abc_df = abc_clf.classify('product', 'total sold')This way you'll get new dataframe with classified products.producttotal soldclassfade cream27000Apowders24000Ashadows18000Amascara16000Blipstick6000Bconcealer5000Csculptors4000CYou also can use brief_abc method to get aggregated informationabc_clf.brief_abc(abc_df)classtotal soldA69000B16000C15000You can plot pareto chart.from abc_classification.abc_visualiser import pareto_chart
pareto_chart(abc_df, 'total_sold', 'product') |
abc-classroom | Why ABC ClassroomMany educators teaching data science are using GitHub Classroom as a way to teach students
both git and GitHub skills and also potentially collaboration skills that align
with open source software development best practices. However there are many steps
associated with using GitHub classroom to manage a class.Abc-Classroom contains a suite of command-line utilities that make it easier to
manage a class of students using GitHub classroom by:Making it easier to create template assignment directories that are directly connected to your classroom organizationMaking it easier to update those assignments and(still under development) making it easier to clone all student assignments for grading.We are currently using nbgrader in our workflow and are thus building this tool
out to support the use of nbgrader as well.Install abc-classroomabc-classroom is under significant development currently. We are occasionally
pushing releases to pypi and conda-forge.For now, install from PyPi using:$ pip install abc-classroomOr conda-forge:$ conda install -c conda-forge abc-classroomOr to get the most current updates, clone this repo and run:$ pip install -e .to install the development version.Use Abc-classroomBecause this is a command line set of tools, you will need to ensure that abc-classroom
is installed in the active environment that you are using for your class.Active Maintainers / DevelopersHow to ContributeWe welcome contributions to abc-classroom as we are developing it and beyond! Please be sure to check out ourcontributing guidelinesfor more information about submitting pull requests or changes to abc-classroom.License & CitationBSD-3 |
abcd | UsageFull documentation athttp://digger-build-cli.readthedocs.io.RequirementsIf running outside a container:Download and install conda:http://conda.pydata.org/miniconda.htmlAfter cloning the repository run:condaenvcreate-fenv.yamlpython=3.5.1To activate the environment run (might need a new terminal window or
reload bashrc/bash_profile):source activate diggerYou will also need Node 4.x, NPM, Cordova >=6 and Java 8 on your
machine.Some requirements are needed to run it outside of a container:Installationpythonsetup.pyinstallTestsRequirementsInstalling development dependencies:pipinstall-rrequirements.txtTests will download all templates from their Github repository (master
branch) and will try to build it.If running outside of the containerPrepare# create a folder for Gradle cachemkdir/gradle-cache# make sure you have write permissionschown-R${USER}/gradle-cacheAlso, make sure you have Android SDK on your machine and$ANDROID_HOMEis set.setup.pypythonsetup.pytestusing py.test directly (from digger project root folder)py.test-sRunning an individual testFor example:py.test-stests/test_build.py |
abcd-0329 | No description available on PyPI. |
abcddb2vcard | abcddb2vcardThis python script reads an AddressBook database file (AddressBook-v22.abcddb) and export its content to a vCard file (.vcf).I created this script to automate my contacts backup procedure.
The output of this script should be exactly the same as dragging and dropping the “All Contacts” card.Usagepython3abcddb2vcard.pybackup/contacts_$(date+"%Y-%m-%d").vcfassuming db is located at "~/Library/Application Support/AddressBook/AddressBook-v22.abcddb"Export into individual filespython3abcddb2vcard.pyoutdir-s'path/%{fullname}.vcf'Extract contact imagespython3vcard2image.pyAllContacts.vcf./profile_pics/Supported data fieldsfirstname,lastname,middlename,nameprefix,namesuffix,nickname,maidenname,phonetic_firstname,phonetic_middlename,phonetic_lastname,phonetic_organization,organization,department,jobtitle,birthday,[email],[phone],[address],[socialprofile],note,[url],[xmpp-service],image,iscompanyLimitationsTheimagefield currently only supports JPG images.
I have honestly no idea where PNG images are stored.
For PNGs the database only stores a UUID instead of the file itself.
If you happen to know where I can find these, open an issue or pull request.DisclaimerYou should check the output for yourself before using it in a production environment.
I have tested the script with many arbitrary fields, however there may be some edge cases missing.
Feel free to create an issue for missing or wrong field values.Note:The output ofdifforFileMerge.appcan be different to this output.
Apples does some weird transformations on vcf export that are not only unnecessary but in many cases break the re-import of the file. |
abcd-distribution | No description available on PyPI. |
abcd-distributions | No description available on PyPI. |
abcde | No description available on PyPI. |
abcdeep | No description available on PyPI. |
abcdef | No description available on PyPI. |
abcdefg | No description available on PyPI. |
abcdefgh | A package for electrophysiology data analysis. |
abc-delegation | abc-delegationA tool for automated delegation with abstract base classes.This metaclass enables creation of delegating classes
inheriting from an abstract base class.This technique is impossible with regular__getattr__approach for delegation,
so normally, you would have to define every delegated method explicitly.
Not any moreThe metaclasses also enable optional validation of the delegate attributes
to ensure they have all of the methods required by the parent object.Installation:pip install abc-delegationBasic usage:fromabcimportABCMetafromabc_delegationimportdelegation_metaclassclassA(metaclass=ABCMeta):@abstractmethoddefbar(self):pass@abstractmethoddeffoo(self):passclassB:defbar(self):return"B bar"deffoo(self):return"B foo"classC(A,metaclass=delegation_metaclass("my_delegate")):def__init__(self,b):self.my_delegate=bdeffoo(self):return"C foo"c=C(B())assertc.foo()=="C foo"assertc.bar()=="B bar"ValidationclassA(metaclass=ABCMeta):@abstractmethoddefbar(self):pass@abstractmethoddeffoo(self):passclassB:pass# validation is on by defaultclassC(A,metaclass=delegation_metaclass("_delegate")):def__init__(self,b):self._delegate=bdeffoo(self):return"C foo"C(B())# Trying to instantiate C class with B delegate which is missing 'bar' method# Validation raises an error:# TypeError: Can't instantiate bar: missing attribute bar in the delegate attribute _delegateMultiple delegates:fromabcimportABCMetafromabc_delegationimportmulti_delegation_metaclassclassA(metaclass=ABCMeta):@abstractmethoddefbar(self):pass@abstractmethoddeffoo(self):pass@abstractmethoddefbaz(self):passclassB:defbar(self):return"B bar"deffoo(self):return"B foo"classX:defbaz(self):return"X baz"classC(A,metaclass=multi_delegation_metaclass("_delegate1","_delegate2")):def__init__(self,d1,d2):self._delegate1=d1self._delegate2=d2deffoo(self):return"C foo"c=C(B(),X())assertc.bar()=="B bar"assertc.foo()=="C foo"assertc.baz()=="X baz"Please refer to the unit tests for more examples. |
abcDict | abcDict |
abcdijklm.py | Just Use yemNothing |
abc-distributions | No description available on PyPI. |
abcdmini | Failed to fetch description. HTTP Status Code: 404 |
abcd-package | A small example package |
abcd-pyhf | pyhf-based implementation of the ABCD method for background estimationInstructions for LXPLUSThe code can be run on LXPLUS by following the instructions below.Create a virtual Python environment:python3-mvenvabcd-pyhfThis will create a directory namedabcd-pyhfthat will contain all the necessary packages to run the code.
Activate the virtual Python environment with the following command:sourceabcd-pyhf/bin/activateYou can shut down the virtual Python environment at any time with the Bash commanddeactivate.
You can later reactivate the environment by running the Bash commandsource abcd-pyhf/bin/activate.To run the code, you will have to download the necessary packages in the Python environment (this only needs to be done once):pipinstall--upgradepip
pipinstallabcd-pyhfYou can then use the package in Python:fromabcd_pyhfimportABCD |
abcdrl | abcdRL(Implement a RL algorithm in four simple steps)English |简体中文abcdRL is aModular Single-file Reinforcement Learning Algorithms Librarythat provides modular design without strict and clean single-file implementation.When reading the code, understand the full implementation details of the algorithm in the single file quickly; When modifying the algorithm, benefiting from a lightweight modular design, only need to focus on a small number of modules.abcdRL mainly references the single-file design philosophy ofvwxyzjn/cleanrland the module design ofPaddlePaddle/PARL.Documentation ➡️docs.abcdrl.xyzRoadmap🗺️#57🚀 QuickstartOpen the project in Gitpod🌐 and start coding immediately.Using Docker📦:# 0. Prerequisites: Docker & Nvidia Drive & NVIDIA Container Toolkit# 1. Run DQN algorithmdockerrun--rm--gpusallsdpkjc/abcdrlpythonabcdrl/dqn.pyFor detailed installation instructions 👀🐼 Features👨👩👧👦 Unified code structure📄 Single-file implementation🐷 Low code reuse📐 Minimizing code differences📈 Tensorboard & Wandb support🛤 PEP8(code style) & PEP526(type hint) compliant🗽 Design Philosophy"Copy📋",not "Inheritance🧬""Single-file📜",not "Multi-file📚""Features reuse🛠",not "Algorithms reuse🖨""Unified logic🤖",not "Unified interface🔌"✅ Implemented AlgorithmsWeights & Biases Benchmark Report ➡️report.abcdrl.xyzDeep Q Network (DQN)Deep Deterministic Policy Gradient (DDPG)Twin Delayed Deep Deterministic Policy Gradient (TD3)Soft Actor-Critic (SAC)Proximal Policy Optimization (PPO)Double Deep Q Network (DDQN)Prioritized Deep Q Network (PDQN)Citing abcdRL@misc{zhao_abcdrl_2022,author={Yanxiao, Zhao},month={12},title={{abcdRL: Modular Single-file Reinforcement Learning Algorithms Library}},url={https://github.com/sdpkjc/abcdrl},year={2022}} |
abcd-seth | No description available on PyPI. |
abcd-yt98 | No description available on PyPI. |
abcd-yt9898 | No description available on PyPI. |
abcEconomics | abcEconomics is a Python based modeling platform for economic simulations.
abcEconomics comes with standard functions to simulations of trade, production
and consumption. The modeler can concentrate on implementing
the logic and decisions of an agents; abcEconomics takes care of all exchange
of goods and production and consumption.In abcEconomics, goods have the physical properties of
goods in reality in the sense that if agent A gives a good to agent B, then
- unlike information - agent B receives the good and agent B does not have
the good anymore.
The ownership and transformations (production or consumption) of goods are
automatically handled by the platform.abcEconomics models are programmed in standard Python, stock functions of agents
can be inherited from archetype classes (Firm or Household). The only
not-so-standard Python is that agents are executed in parallel by the
Simulation class (in start.py).abcEconomics allows the modeler to program agents as ordinary Python class-objects,
but run the simulation on a multi-core/processor computer. It takes no
effort or intervention from the modeler to run the simulation on a
multi-core system.
The speed advantages of using abcEconomics with multi-processes enabled.
abcEconomics are typically only observed for 10000 agents and more. Below, it
might be slower than pure python implementation. abcEconomics supports pypy3,
which is approximately 10 times faster than CPython.abcEconomics is a scheduler and a set of agent classes.
According to the schedule the simulation class calls - each sub-round - agents
to execute some actions. Each agent executes these actions
using some of the build-in functions, such as trade, production and
consumption of abcEconomics. The agents can use the full set of commands of the
Python general purpose language.The audience of abcEconomics are economists that want to model agent-based
models of trade and production.abcEconomics does support an accounting framework
for financial simulations.ESL can be downloaded here.abcEconomics runs on macOS, Windows, and Linux. abcEconomics runs 10x faster on pypy!Install with:pip3 install abcEconomicsThe documentation is here:http://abce.readthedocs.io/An example is here:Insurance MarketA code example is here:Jupyter TutorialMore code examples are here:https://github.com/AB-CE/examples |
abcFinance | Economic agent-based models with financial accountingabcFinance (short for 'agent-based computational Finance') provides tools for using standard double-entry bookkeeping methods either directly or within an agent-based modelling framework. It is a sister library to theabcEconomics(agent-based computational Economics) library.Direct use of double-entry bookkeeping toolsTheLedgerclass implements an accounting system. Booking statements are recorded through thebook()method. The basic syntax works as follows:accountingsystem = Ledger()
accountingsystem.make_stock_accounts('Assets', 'Liabilities')
accountingsystem.book(debit=[('Assets',100)], credit=[('Liabilities',100)]wheredebitandcreditare lists of tuples('account', amount)of accounts that should be booked byamounton the debit and credit side, respectively. The total sum of debits and credits needs to be equal in one booking statement. Accounts have to be declared as either stock or flow accounts before they can be booked.The balance sheet is composed of all stock accounts and includes an equity account whose name can be set using the optionalresidual_account_nameflag in the constructor ofLedger. The profit and loss statement is composed of all flow accounts. It can be viewed using theprint_profit_and_loss()statement. The profit or loss for the period can be booked against equity using thebook_end_of_period()method, which also resets all flow accounts. The balance sheet can be printed using theprint_balance_sheet()method.draw_balance_sheet()returns the string representation of an SVG image of the balance sheet. Several other helpful methods are available.Extensive examples can be found in theexamples\money_creationfolder.Use in an agent-based modelling systemTheLedgerclass can be used as an attribute for anAgentclass in an agent-based modelling system, enabling the use of financial accounting within agent-based models. One implementation is provided in the form of theAbcFinanceAgentclass, which inherits from theAgentclass in theabcEconomicslibrary. abcEconomics is designed to be compatible with abcFinance and provides several methods to facilitate the use of abcFinance methods in agent-based models. The accounting system provided in abcFinance can in principle be used with any agent-based modelling system. |
abcgan | ABCGANThis project uses a generative adversarial network (GAN) to produce a Generator and a Discriminator to characterize the normal atmospheric background. It provides the ability to sample atmospheric parameters, creating full altitude profiles of the sampled measurements. The current system is trained on over 10 years of Incoherent Scatter Radar data collected in Alaska at the Poker Flat Research Range.Currently the project supports the sampling of low frequency measurements conditioned on high altitude drivers (solar flux, solar zenith angle, etc.). The project goal is to augment this initial capability through generation of high frequency distrubances (waves) as well as allowing conditioning on ground based drivers (terrain, etc.).Installing abcganThis package is available on PyPI and can be installed with pip. It is
best to do this in a Python virtual environment:python-mvenvvenv
.venv/bin/activate
pipinstallabcganIt requires Python 3.8+ and uses PyTorch 1.8+.Downloading the tutorialsThe tutorials are available as Jupyter notebooks and are located along
with sample data in the tutorial directory in the github repository.
You can download these tutorials with the abcgan-cmd program which is
installed along with the abcgan package.After downloading the tutorials, install the required packages listed
in tutorials/requirements.txt using pip. You can then start Jupyter Lab
and load the tutorial notebook tutorial/demo.ipynb.The data files and models used in the tutorials are approximately 600Mb
in size. Use the -m flag to abcgan-cmd to download them with the tutorials.abcgan-cmd -m download tutorials
pip install -r tutorials/requirements.txt
jupyter labRunning the tutorials on BinderYou can run the tutorial notebooks at any time onBinder. A Docker container will be automatically created with the abcgan package and tutorials.https://mybinder.org/v2/gh/sri-geospace/atmosense-abcgan/HEAD?labpath=tutorials%2Fdemo.ipynbContentsThe content of this repository entails:Source code inside 'src/abcgan'Test code inside 'test'Tutorials inside 'tutorials'Pre-trained models inside 'models'Helper scripts in 'contrib'Installation from sourceInstall Pytorch from thePytorch pagePytorch installation will be specific to your system configuraiton depending on gpu availability and drivers.gitclonehttps://github.com/sri-geospace/atmosense-abcgan.gitFor end user installation:pip install atmosense-abcganFor development:pip install -e atmosense-abcganBuilding the documentationThe package documentation is available onRead the Docs. You may also build the docs locatlly. The configuration files and document sources are in the docs/ directory, including a requirements file with the necessary dependencies.cd docs
pip install -r requirements.txt
make htmlThe API source files are generated usingapi-doc:sphinx-apidoc -o . ../src/abcganNote that .rst files are generated from the installed module not the source tree; to reference local changes make sure the installation is performed with pip install -e .Add the lines to conf.py if not there already:.. toctree::
:maxdepth: 2
:caption: Contents:
abcgan
modulesFinally, build the docs:make clean
make htmlRun testsMake sure to have completed the development. From the top level directory 'atomesense-abcgan' run:python-munittestUsing the libraryThis is a library that can be imported directly in python and used. For example usage see 'tutorials/demo.py'.ContactFor questions please contact Andrew [email protected] |
abcgan-drivers | atmosense-abcgan-driversSoftware to generate the drivers for ABCGANInstallationThis package can be installed with pippip install git+https://github.com/sri-geospace/atmosense-abcgan-drivers.gitThe following external dependencies are required, some of which may need to be installed manually.numpyscipyh5pyflipchemapexpyskyfieldspacepypytzUsageThis package can be used to generate a full set of drivers both within other python scripts and as a stand-alone command line program.Python ScriptIn the following example, drivers are calculated once an hour on January 1, 2020.importabcdriversimportdatetimeasdtstarttime=dt.datetime(2020,1,1,0,0,0)endtime=dt.datetime(2020,1,2,0,0,0)timestep=1.0# in decimal hourssite_lat=65.5site_lon=-147.5# generate an array of times to calculate drivers attimes,utime=abcdrivers.generate_time_array(starttime,endtime,timestep)# calculate drivers for each timedrivers=abcdrivers.collect_drivers(times,site_lat,site_lon)Note that itcollect_drivers()can take in any array ofdatetime.datetimeobjects and it is not necessary to use thegenerate_time_array()function if the time array is created elsewhere.Command LineIn order to generate driver from the command line, you must create a config file following the format of the example provided in the project root directory.abcgan-drivers config.iniDrivers will be saved to an output hdf5 file along with some other information about the processing. The output file name is specified in the config file.DriversKeyFull NameDescriptionMLTMagnetic Local TimeLocal time calculated used magnetic coordinate systemSLTSolar Local TimeLocal time as determined by the sun's positionMLATMagnetic LatitudeApex magnetic latitudeSZASolar Zenith AngleAngle between the sun and local zenithShadHeightShadow HeightHeight of the Earth's shadow in the atmospheremoon_xLunar Position (x)X component of Lunar position in GSE coordinatesmoon_yLunar Position (y)Y component of Lunar position in GSE coordinatesmoon_zLunar Position (z)Z component of Lunar position in GSE coordinatesmoon_phaseLunar PhaseLunar phase in degreesF10.7F10.7 Solar Radio FluxSolar rado flux at 10.7 cm (2800 MHz) in s.f.u (10^-22 W m^-2 Hz^-1)F10.7avgAverage F10.7 Solar Radio FluxAverage solar radio flux at 10.7 cm (2800 MHz) in s.f.u (10^-22 W m^-2 Hz^-1)apap Geomagnetic IndexThree hour equivalent planetary amplitudeApDaily Ap IndexDaily equivalent planetary amplitudedstDisturbance storm-time (Dst) indexIndex for geomagnetic storm activityTCIThermosphere Climate Index60-day running average of global cooling power radiated from the thermosphereMEIMultivariate ESNO IndexMeasure of the El Nino/Southern Oscillation (ESNO)/sea surface temperatureRMM1First MJO IndexFirst component of the Madden-Julian Oscillation IndicesRMM2Second MJO IndexSecond component of the Madden-Julian Oscillation IndicesT*Stratospheric TemperatureStratospheric Temperature at pressure level *U*Stratospheric WindStratospheric Wind at pressure level *Time Range LimitationsMany drivers are extracted from data files included as package data. Consequentially, this package can only calculate drivers in the time ranges these data files cover. To calculate drivers for recent times, the data files may need to be manually updated (seeabcdrivers/data_files/README.md). This package cannot calculate drivers for future times. |
abcgh | Web-Statsgenerate website reportsWeb-stats is a simple library that allows you to generate website reports in less than 60 seconds , by scraping data frominsites.comonly10requests/ip are allowedyou will have to use proxiesonly60 secondsto generate a reportInstallationpipinstallweb-statsUsageimportgenerate_reportfromweb-statsgenerate_report('https://www.dafk.net/what/')Output example[{'name':'Overall','rating':'good','value':'6.7'},{'name':'Accessibility','rating':'better','value':'8.3'},{'name':'Experience','rating':'good','value':'5.2'},{'name':'Marketing','rating':'good','value':'5.1'},{'name':'Technology','rating':'better','value':'8.1'},{'name':'Twitter','value':'0.0'},{'name':'Analytics','value':'0.0'},{'name':'Printability','value':'0.0'},{'name':'Freshness','value':'0.0'},{'name':'Meta tags','value':'1.0'},{'name':'Mobile','value':'3.0'},{'name':'Popularity','value':'5.6'},{'name':'Amount of content','value':'7.8'},{'name':'Server behavior','value':'10.0'},{'name':'Page titles','value':'10.0'},{'name':'Headings','value':'10.0'},{'name':'Incoming links','value':'10.0'},{'name':'Images','value':'10.0'},{'name':'Internal links','value':'10.0'},{'name':'URL format','value':'10.0'},{'name':'Domain age','value':'i'}]LicenseMITfree stuff , hell yeah ! |
abc-graphene-sqlalchemy | Please readUPGRADE-v2.0.mdto learn how to upgrade to Graphene2.0.Graphene-SQLAlchemyASQLAlchemyintegration forGraphene.InstallationFor instaling graphene, just run this command in your shellpipinstall"graphene-sqlalchemy>=2.0"ExamplesHere is a simple SQLAlchemy model:fromsqlalchemyimportColumn,Integer,Stringfromsqlalchemy.ormimportbackref,relationshipfromsqlalchemy.ext.declarativeimportdeclarative_baseBase=declarative_base()classUserModel(Base):__tablename__='department'id=Column(Integer,primary_key=True)name=Column(String)last_name=Column(String)To create a GraphQL schema for it you simply have to write the
following:fromabc_graphene_sqlalchemyimportSQLAlchemyObjectTypeclassUser(SQLAlchemyObjectType):classMeta:model=UserModelclassQuery(graphene.ObjectType):users=graphene.List(User)defresolve_users(self,info):query=User.get_query(info)# SQLAlchemy queryreturnquery.all()schema=graphene.Schema(query=Query)Then you can simply query the schema:query='''
query {
users {
name,
lastName
}
}
'''result=schema.execute(query,context_value={'session':db_session})To learn more check out the followingexamples:Full example:Flask SQLAlchemy
exampleContributingAfter cloning this repo, ensure dependencies are installed by running:pythonsetup.pyinstallAfter developing, the full test suite can be evaluated by running:pythonsetup.pytest# Use --pytest-args="-v -s" for verbose mode |
abch-tree-sitter | py-tree-sitterThis module provides Python bindings to thetree-sitterparsing library.InstallationThis package currently only works with Python 3. There are no library dependencies, the package is distributed as a CPython-compiled wheel.pip3installabch-tree-sitterAcknowledgmentsThis is a fork ofpy-tree-sitterby Max Brunsfeld with UTF-16 support added and distributed as CPython-compiled wheels.UsageSetupFirst you'll need a Tree-sitter language implementation for each language that you want to parse. You can clone some of theexisting language reposorcreate your own:gitclonehttps://github.com/tree-sitter/tree-sitter-go
gitclonehttps://github.com/tree-sitter/tree-sitter-javascript
gitclonehttps://github.com/tree-sitter/tree-sitter-pythonUse theLanguage.build_librarymethod to compile these into a library that's usable from Python. This function will return immediately if the library has already been compiled since the last time its source code was modified:fromtree_sitterimportLanguage,ParserLanguage.build_library(# Store the library in the `build` directory'build/my-languages.so',# Include one or more languages['vendor/tree-sitter-go','vendor/tree-sitter-javascript','vendor/tree-sitter-python'])Load the languages into your app asLanguageobjects:GO_LANGUAGE=Language('build/my-languages.so','go')JS_LANGUAGE=Language('build/my-languages.so','javascript')PY_LANGUAGE=Language('build/my-languages.so','python')Basic ParsingCreate aParserand configure it to use one of the languages:parser=Parser()parser.set_language(PY_LANGUAGE)Parse some source code:tree=parser.parse(bytes("""def foo():if bar:baz()""","utf8"))If you have your source code in some data structure other than a bytes object,
you can pass a "read" callable to the parse function.The read callable can use either the byte offset or point tuple to read from
buffer and return source code as bytes object. An empty bytes object or None
terminates parsing for that line. The default encoding is utf8.For example, to use the byte offset:src=bytes("""def foo():if bar:baz()""","utf8")defread_callable(byte_offset,point):returnsrc[byte_offset:byte_offset+1]tree=parser.parse(read_callable)And to use the point:src_lines=["def foo():\n"," if bar:\n"," baz()"]defread_callable(byte_offset,point):row,column=pointifrow>=len(src_lines)orcolumn>=len(src_lines[row]):returnNonereturnsrc_lines[row][column:].encode('utf8')tree=parser.parse(read_callable)Or with utf16 encoding:tree=parser.parse(bytes("""def foo():if bar:baz()""","utf16"),encoding="utf16")src=bytes("""def foo():if bar:baz()""","utf16")defread_callable(byte_offset,point):returnsrc[byte_offset:byte_offset+2]tree=parser.parse(read_callable,encoding="utf16")src_lines=["def foo():\n"," if bar:\n"," baz()"]defread_callable(byte_offset,point):row,column=pointifrow>=len(src_lines)orcolumn>=len(src_lines[row].encode("utf-16-le")):returnNoneret=src_lines[row].encode("utf-16-le")[column:]returnrettree=parser.parse(read_callable,encoding="utf16")Inspect the resultingTree:root_node=tree.root_nodeassertroot_node.type=='module'assertroot_node.start_point==(1,0)assertroot_node.end_point==(3,13)function_node=root_node.children[0]assertfunction_node.type=='function_definition'assertfunction_node.child_by_field_name('name').type=='identifier'function_name_node=function_node.children[1]assertfunction_name_node.type=='identifier'assertfunction_name_node.start_point==(1,4)assertfunction_name_node.end_point==(1,7)assertroot_node.sexp()=="(module ""(function_definition ""name: (identifier) ""parameters: (parameters) ""body: (block ""(if_statement ""condition: (identifier) ""consequence: (block ""(expression_statement (call ""function: (identifier) ""arguments: (argument_list))))))))"Walking Syntax TreesIf you need to traverse a large number of nodes efficiently, you can use
aTreeCursor:cursor=tree.walk()assertcursor.node.type=='module'assertcursor.goto_first_child()assertcursor.node.type=='function_definition'assertcursor.goto_first_child()assertcursor.node.type=='def'# Returns `False` because the `def` node has no childrenassertnotcursor.goto_first_child()assertcursor.goto_next_sibling()assertcursor.node.type=='identifier'assertcursor.goto_next_sibling()assertcursor.node.type=='parameters'assertcursor.goto_parent()assertcursor.node.type=='function_definition'EditingWhen a source file is edited, you can edit the syntax tree to keep it in sync with the source:tree.edit(start_byte=5,old_end_byte=5,new_end_byte=5+2,start_point=(0,5),old_end_point=(0,5),new_end_point=(0,5+2),)Then, when you're ready to incorporate the changes into a new syntax tree,
you can callParser.parseagain, but pass in the old tree:new_tree=parser.parse(new_source,tree)This will run much faster than if you were parsing from scratch.TheTree.get_changed_rangesmethod can be called on theoldtree to return
the list of ranges whose syntactic structure has been changed:forchanged_rangeintree.get_changed_ranges(new_tree):print('Changed range:')print(f' Start point{changed_range.start_point}')print(f' Start byte{changed_range.start_byte}')print(f' End point{changed_range.end_point}')print(f' End byte{changed_range.end_byte}')Pattern-matchingYou can search for patterns in a syntax tree using atree query:query=PY_LANGUAGE.query("""(function_definitionname: (identifier) @function.def)(callfunction: (identifier) @function.call)""")captures=query.captures(tree.root_node)assertlen(captures)==2assertcaptures[0][0]==function_name_nodeassertcaptures[0][1]=="function.def"TheQuery.captures()method takes optionalstart_point,end_point,start_byteandend_bytekeyword arguments which can be used to restrict the
query's range. Only one of the..._byteor..._pointpairs need to be given
to restrict the range. If all are omitted, the entire range of the passed node
is used. |
abch-tree-sitter-solidity | 🌴 tree-sitter-solidity💡 this grammar is still in development, the structure of the generated AST is not stableThis repository contains a grammar fortree-sitter.The goal of this project is to provide an parser efficient low-dependency parser for solidity which targets most solidity versions in use and is designed for enabling metaprogramming.Navigating this repositoryThe primary file in this repository isgrammar.jswhich describes the tree-sitter grammar.# Primary file:
grammar.js
# Tests:
/test/**/*
# Auto generated:
/src/**/*
index.js
binding.gypReferences-> Ethereum solidity grammar:https://github.com/ethereum/solidity/blob/develop/docs/grammar/SolidityParser.g4https://github.com/ethereum/solidity/blob/develop/docs/grammar/SolidityLexer.g4https://docs.soliditylang.org/en/latest/grammar.html?#-> Tree-sitter javascript grammar:https://github.com/tree-sitter/tree-sitter-javascript/blob/master/grammar.js-> Solidity antlr grammar:https://github.com/ConsenSys/solidity-parser-antlrMajor inspriration & some structures have been taken from tree-sitter-javascript, a big thanks to the contributors to this repo! |
abci | Py-ABCIBuild Tendermint blockchain applications in Python. It's fun. This library provides the core functionality needed to create Tendermint ABCI applications.Supported Tendermint VersionTendermint0.34.11ABCI0.17.0InstallationRequires Python >= 3.9pip install abciYou'll need a binary version of the Tendermint engine.
Available here:https://github.com/tendermint/tendermint/releasesMake sure the Tendermint version you download matches the current support version of this libraryQuick Start - demoA very simple demo application is included and available from the command line ascounter. You can find the code here:https://github.com/davebryson/py-abci/blob/master/src/example/counter.pyTo try it out:Make sure you have the Tendermint binary setup locally and in your path. To test it's working
open a terminal window and type:>> tendermint versionIt should output your version of Tendermint that should match the currently supported version
of this library.Next, initialize Tendermint by running:>> tendermint initStart the Tendermint node:>> tendermint nodeThe node will start, but will be waiting for you application to start.Open another terminal, and start thecounterapplication. Thecounterwill be available
from within the Python environment where you installedabci>> counterYou'll see the application start, and in the Tendermint terminal, you'll see the output of
blocks being producedNow, open a 3rd terminal window to send some transaction to the blockchain. To do this we'll
use thecurlapplication to send transaction to the local blockchain over http. For example:>> curl http://localhost:26657/broadcast_tx_commit?tx=0x01
>> curl http://localhost:26657/broadcast_tx_commit?tx=0x02The counter application expects you to sendtransactionsas numbers encoded as hex in order: 1,2,3...
It will reject and out-of-order numbers. You can always see the latest accepted value by sending the
request:>> curl http://localhost:26657/abci_queryTo shut down the application enterCTRL-CGet StartedTo start building your own application:Extend theabci.application.BaseApplicationclassImplement the Tendermint ABCI callbacks - seehttps://docs.tendermint.com/v0.34/spec/abcifor details on how they workStart it:fromabci.serverimportABCIServerapp=ABCIServer(app=MyApplication())app.run()See thecounter.pyapplication in theexampledirectoryhttps://github.com/davebryson/py-abci/blob/master/src/example/counter.pyfor a full example.Developing on the code baseIf you're working directly on the code base. Install a local editable version:pip install --editable '.[test]'Updating Protobuf codeYou should only re-generate the protobuf code if you're updating the associated protobuf files,
and/or contributing to this code base. You do not need to rebuild protos to create apps.A note on protobuf: The primary code directory isabci, but you'll notice additional
directories:gogoproto,tendermint, andprotos.Thegogoprotoandtendermintdirectories are the protobuf generated code used byabci. It adds proper Python modules and preserves all the import statements used by Tendermint for the various protobuf files spread
across their codebase. Theprotosdirectory is the source .proto files.To (re)build the protobuf files:Installprotocso it's available in your PATH as a commandRunmake update-proto |
abc-instagram | No description available on PyPI. |
abc-instantid | No description available on PyPI. |
abckeys | ABC KeysDescriptionThis project contains keys used by the askbisi backend infrastructure and its APIs. It is maintained by the askbisi engineering team. |
abclf | American-British-variety-classifierA minimalistic spelling- and vocabulary-based American-vs-British variety classifier.DescriptionThis classifier is based on theVarCon database. First the database was read and used in its entirety, after which progressive prunings were performed to improve performance.The classifier performs rudimentary preprocessing (some weird character deletion to reduce the odds of discarding non-important words) and then checks all lowercase nonnumerical words if they are present in the dictionary. The final step is assigning variety to the input text, for which we use the following logic:for documents with no identified American or British lexemes it returnsUNK,if one variant has more than twice as many identified words as the other, it classifies the instance as the more frequent variant,else it classifies it asMIX.InstallationpipinstallabclfUseimportabclftext="The flautist heard a rumour about the gray haired clarinettist in a wollen pullover"abclf.get_variant(text)# 'B'AuthorsPeter RupnikTaja KuzmanNikola LjubešićCopyright of the original VarCon databaseCopyright 2000-2020 by Kevin Atkinson ([email protected]) and Benjamin
Titze ([email protected]).
Copyright 2000-2019 by Kevin Atkinson
Permission to use, copy, modify, distribute and sell this array, the
associated software, and its documentation for any purpose is hereby
granted without fee, provided that the above copyright notice appears
in all copies and that both that copyright notice and this permission
notice appear in supporting documentation. Kevin Atkinson makes no
representations about the suitability of this array for any
purpose. It is provided "as is" without express or implied warranty.
Copyright 2016 by Benjamin Titze
Permission to use, copy, modify, distribute and sell this array, the
associated software, and its documentation for any purpose is hereby
granted without fee, provided that the above copyright notice appears
in all copies and that both that copyright notice and this permission
notice appear in supporting documentation. Benjamin Titze makes no
representations about the suitability of this array for any
purpose. It is provided "as is" without express or implied warranty.
Since the original words lists come from the Ispell distribution:
Copyright 1993, Geoff Kuenning, Granada Hills, CA
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. All modifications to the source code must be clearly marked as
such. Binary redistributions based on modified source code
must be clearly marked as modified versions in the documentation
and/or other materials provided with the distribution.
(clause 4 removed with permission from Geoff Kuenning)
5. The name of Geoff Kuenning may not be used to endorse or promote
products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY GEOFF KUENNING 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 GEOFF KUENNING 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. |
abclient | abclientis a client library for EISOO AnyBackup APIs.abclientallows openstack-karbor to create backups for databases and filesystems.InstallationTo install abclient, simply:$pipinstallabclientHow to use>>>fromabclientimportbackup_manager>>>ab=backup_manager.eisooBackupManager('IP_ADDR','MACHINE_CODE')>>>ab.start_backup(...)API SupportCreate backup for ORACLE Databasemore API will be supported in the future.LicenseApache License Version 2.0http://www.apache.org/licenses/LICENSE-2.0 |
abclinuxuapi | IntroductionThis module contains basic API for crawling thehttp://abclinuxu.czwebsite.InstallationModule is hosted atPYPI, and
can be installed usingPIP:pip install abclinuxuapiDocumentationFull module documentation is hosted at ReadTheDocs:http://abclinuxuapi.readthedocs.orgDisclaimerThe API was made by me (Bystroushaak) and it is not officially related to thehttp://abclinuxu.czproject.ExamplesIterate over all published blogs:>>>importabclinuxuapi>>>forbloginabclinuxuapi.iter_blogposts():...printblog.title...Czech blacklist 1.0.21
iOS aplikace, filemanager, prehravani multimedii...
ENCFS - lze doporucit? mozna uskali?
Vývoj v C# + Oracle ODP.NET + EntityFramework
Skončila svoboda?
Abclinuxu - vyjádření k útokům
Eliptické křivky - vztah Weierstrass, Montgomery, Edwards
kopirovanie raspbianu na microsd kartu
Půjdem dolem, půjdem horem?
Podotčeno…
Abclinuxu presmerovano...
Dead man
Valentýn 2018 (genderově korektní mikrozápisek)
Textilosaurus - co je nového?
Kvíz: Znáte český kraj?
Název filmu
Trilium Notes jako platforma pro mini-aplikace
Marketingový "průzkum" pro zjištění obětí na další útok
Vítězný únor 2018
Reverse engineering komunikace Xorg a nvidia driveru
Vtipná konstrukce v shellu
Anketa: Kdy budou další presidentské volby v ČR?
Debian 9 a data corruption s detektivní zápletkou
Proč je tolik povyku s meltdownem mezi normálními usery
Tabletové skúsenosti pre ľahší život.
...Get structured information for specific blog:>>>blog=abclinuxuapi.Blogpost("https://www.abclinuxu.cz/blog/bystroushaak/2017/9/autorske-okenko-neal-asher",lazy=False)>>>blog.created_ts1506733800.0>>>blog.last_modified_ts1508752260.0>>>blog.tags['knihy','ProtectedByTagManager','recenze','sci-fi']>>>blog.has_tuxFalse>>>blog.ratingRating(100%@5)>>>blog.readed1470>>>blog.comments_n73>>>blog.comments[65]Comment(username=andrea,id=18)>>>blog.comments[65].registeredFalse>>>blog.comments[65].timestamp1506861120.0>>>printblog.comments[65].textsuprblogísky,rádaječtu.<pclass="separator"></p>myslímžejsemtuodTebevidělasouhrnknih,kteréjsipřečetl.mělbystřebatop50sci-fi,kterébychsiurčitěmělapřečíst?neboalespoňtop10,prvnítrojka?>>>blog.comments[65].responses[Comment(username=bystroushaak,id=19)]>>>printblog.text<h2>Autorskéokénko:NealAsher</h2><p>Dvacátéhozáříjsemdočetlvšechno...Changelog0.4.16abclinuxu_uploader.py; detect images bigger than 1MB. Added –url parameter to handle these.concept.py; Detect upload of images bigger than 1MB and raise ValueError in such cases.0.4.15Added better error detection when too long title is used.0.4.14Fixed bug in parsing of number of comments from blog description.0.4.13Fixed parsing ofhttp://www.abclinuxu.cz/blog/luv/2016/4/mockgeofix-mock-geolokace-kompatibilni-s-android-emulatoremwhere there are no comments.0.4.12Added abclinxuapi.number_of_blog_pages() function to find out how many blogs is there.0.4.11Added banlist for comment parsing on certain blogs (see HTML source onhttp://abclinuxu.cz/blog/Strider_BSD_koutek/2006/8/objevil-jsem-amerikufor details).0.4.0 - 0.4.10Added badges to README.Blogpost.commentsare now by default blank list instead of None.Fixed bugs in uploader.Parsing of the tags updated.Added support for Blog.uid.Fixed bugs in tests (new year parsing).Added possibility to bypass lazy tag parsing.Fixed bug in date parsing function.Added support for parsing of more obscure date formats used by articles on abclinuxu.Fixed another bug in date parsing function.Addedverify=False, because the SSL library pisses me off.Added another special case of parsing the date.Fixed another problem with date formats.Fixed problem with parsing comments on thehttp://abclinuxu.cz/blog/msk/2016/8/hlada-sa-linux-embedded-vyvojar- there are no links to comments.Fixed comment parsing in case ofhttp://abclinuxu.cz/blog/leos/2007/2/prepis-diskusniho-fora-hw-sekce#310.3.0 - 0.3.11Added parsing of comments under blogposts.Fixed bugs.Fixed bugs in user.py.Addediter_blogposts(),first_blog_page()functions for browsing the bloglist.ImplementedBlogpost.get_image_urls().Added date_izolator(). Fixed bugs in comments parsing with relative dates.Fixed bug in parsing of Blogpost’s content.Added blog iterator tor User object.Fixed #4 - bug in username parsing.Fixed parsing of censored comments.AddedComment.censored.Comment.registered_userrenamed toComment.registered.Fixed bug which skipped censored comments.Fixed problems with old blogs (different HTML).Implemented #6:.__repr__()for all important classes.Fixed #7 - blogs with opening HTML comments in perex.Fixed bug inBlogpost._parse_content_tag().Another attempt to solve shit in old blogs. There are missing tags, crossed tags and a lot of other shitfucks.Fixed bug caused byhttp://abclinuxu.cz/blog/Mostly_IMDB/2008/6/radeon-hd-4850-a-tak-vubec#17Added a lot of documentation, fixed docstrings and so on.User.has_blog()changed toboolpropertyUser.has_blog.Conceptclass refactored.Added new parameterdataforshared.download().User.ts_to_concept_datemoved toshared.ts_to_concept_date().0.2.0Added a lot of features.Fixed broken setup.py.0.1.0Created.It can be now used to read data from the abclinuxu, but it is incomplete and it will need a lot of work to do. |
abc-live-lib | No description available on PyPI. |
abcloud | No description available on PyPI. |
abcLR | ARTIFICIAL BEE COLONY ALGORITHM WITH LOGISTIC REGRESSION (ABC-LR)ABC-LR is a binary classification method in which the ABC algorithm is used instead of the Gradient Descent algorithm to train the weights in the Logistic Regression classification model. The purpose of the ABC algorithm in the ABC-LR method is to minimize the value of the cost function. The ABC algorithm is a very popular metaheuristic method that can search for solutions both locally and globally in the solution space. In addition, it has been shown in the study that the ABC-LR classification method achieves superior classification success compared to the LR classification method.Although the ABC-LR classification method can handle complex and high-dimensional data, its runtime can be high. Therefore, CPU and GPU parallelized versions of the ABC-LR classification method are presented here, and significant improvements in runtime can be achieved.ABC-LR is written in Python3 and continuously tested with Python 3.7 and 3.10.InstallationInstall ABC-LR via PyPI:pip install abcLROr alternatively, clone the environment:git clone https://github.com/kagandedeturk/ABC-LR.gitCPU Version UsageimportnumpyasnpparallelType=npfromabcLRimportABC_LR_Modelfromsklearn.datasetsimportload_breast_cancerX,y=load_breast_cancer(return_X_y=True)y=y.reshape(-1,1)lb=-16ub=16evaluationNumber=80000# FVS = trainData.shape[1]limit=50P=60MR=0.3L2=0model=ABC_LR_Model(lb=lb,ub=ub,evaluationNumber=evaluationNumber,limit=limit,P=P,MR=MR,L2=L2,parallelType=parallelType)#start_time = dt.datetime.now()model.fit(X,y)#print(f"Run time: {dt.datetime.now()-start_time}")print(f"Result:{model.score(X,y)}")GPU Version UsageimportcupyascpparallelType=cpfromabcLRimportABC_LR_Modelfromsklearn.datasetsimportload_breast_cancerX,y=load_breast_cancer(return_X_y=True)X=parallelType.array(X)y=parallelType.array(y.reshape(-1,1))lb=-16ub=16evaluationNumber=80000# FVS = trainData.shape[1]limit=50P=60MR=0.3L2=0model=ABC_LR_Model(lb=lb,ub=ub,evaluationNumber=evaluationNumber,limit=limit,P=P,MR=MR,L2=L2,parallelType=parallelType)#start_time = dt.datetime.now()model.fit(X,y)#print(f"Run time: {dt.datetime.now()-start_time}")print(f"Result:{model.score(X,y)}")LicenseThis program is free software: you can redistribute it and/or modify
it under the terms of the 3-clause BSD license (please see the LICENSE file).This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.You should have received a copy of the 3-clause BSD license
along with this program (see LICENSE file).
If not, seehere.Copyright (c) 2022, Bilge Kagan Dedeturk ([email protected]) |
abc-matlab.py | MATLAB |
abcmeta | abcmetaPython meta class and abstract method library with restrictions.This library provides a restricted way to validate abstract methods.
The Python's default abstract method library only validates the methods
that exist in the derived classes and nothing else.
What this library provides is apart from that validation it provides
validations over the method's signature.
All you need is to importABCMetaandabstractmethodfrom this library.It works on both annotations and without annotations methods.InstallationYou can install the package bypip:$pipinstallabcmetaNote: abcmeta supports Python3.6+.Quick startfromtypingimportDict,TextfromabcmetaimportABC,abstractmethodclassBase(ABC):@abstractmethoddefmethod_2(self,name:Text,age:int)->Dict[Text,Text]:"""Abstract method."""@abstractmethoddefmethod_3(self,name,age):"""Abstract method."""classDrived(Base):defmethod_2(self,name:Text,age:int)->Dict[Text,Text]:return{"name":"test"}defmethod_3(self,name,age):passIf you put a different signature, it will raise an error with 'diff' format with hints about what you've missed:classDrived(Base):defmethod_2(self,name:Text,age:int)->List[Text]:return{"name":"test"}And it will raise:Traceback(mostrecentcalllast):File"/Workspaces/test.py",line41,in<module>classDrived(Base):File"/usr/lib/python3.9/abc.py",line85,in__new__cls=super().__new__(mcls,name,bases,namespace,**kwargs)File"/abcmeta/__init__.py",line179,in__init_subclass__raiseAttributeError(AttributeError:Signatureofthederivedmethodisnotthesameasparentclass:-method_2(self,name:str,age:int)->Dict[str,str]?^^-----+method_2(self,name:str,age:int)->List[str]?^^Derivedmethodexpectedtoreturnin'typing.Dict[str, str]'type,butreturns'typing.List[str]'For different parameter names:classDrived(Base):defmethod_2(self,username:Text,age:int)->List[Text]:return{"name":"test"}And it will raise:Traceback(mostrecentcalllast):File"/Workspaces/test.py",line41,in<module>classDrived(Base):File"/usr/lib/python3.9/abc.py",line85,in__new__cls=super().__new__(mcls,name,bases,namespace,**kwargs)File"/abcmeta/__init__.py",line180,in__init_subclass__raiseAttributeError(AttributeError:Signatureofthederivedmethodisnotthesameasparentclass:-method_2(self,name:str,age:int)->Dict[str,str]+method_2(self,username:str,age:int)->Dict[str,str]?++++Derivedmethodexpectedtogetnameparamter,butgetsusernameIssueIf you're faced with a problem, please file anissueon Github.ContributeYou're always welcome to contribute to the project! Please file an issue and send your great PR.LicensePlease read theLICENSEfile. |
abcmodel | Failed to fetch description. HTTP Status Code: 404 |
abcmrt16 | ABC-MRT16 Python PackageCode for running articulation band correlation - modified rhyme tests (ABC-MRT).Building and Installing the Package LocallyTo install the package run the following:pip install abcmrt16Alternatively, to build and install the package, clone this repository and run the following
from the root of the git repository :pip install .BackgroundThis software implements the ABC-MRT16 algorithm for objective estimation of
speech intelligibility. The algorithm is discussed in detail in [1] and [2].
ABC-MRT is short for “Articulation Band Correlation Modified Rhyme Test.” The
software was originally written by NTIA/ITS in MATLAB
(https://github.com/NTIA/ABC-MRT16), but has now been ported to Python.The Modified Rhyme Test (MRT) [3] is a protocol for evaluating speech
intelligibility using human subjects. The subjects are presented with the
task of identifying one of six different words that take the phonetic form
CVC. The six options differ only in the leading or trailing consonant.
MRT results take the form of success rates (corrected for guessing) that
range from 0 (guessing) to 1 (correct identification in every case).These success rates form a measure of speech intelligibility in this
specific (MRT) context.Articulation Band Correlation-MRT (ABC-MRT) is a signal processing
algorithm that processes MRT audio files and produces success rates. The
goal of ABC-MRT is to produce success rates that agree with those produced
by MRT. Thus ABC-MRT is an automated or objective version of MRT and no
human subjects are required.ABC-MRT performs a narrowband (nominally 4 kHz) analysis. ABC-MRT16
is applicable to narrowband, wideband, superwideband, and fullband speech.
ABC-MRT processes the first 17 AI bands while ABC-MRT16 processes all 20 AI
bands, as well as an additional "AI Band 21" that covers 7 kHz to 20 kHz.
Of equal importance is that ABC-MRT16 incorporates a model for attention
that allows it to properly operate across the different bandwidths without
any bandwidth detection or switching.Unless backwards compatibility is required, ABC-MRT16 is the recommended
algorithm, even if only narrowband conditions are to be tested. The
attention model makes it superior to ABC-MRT. ABC-MRT16 is the only algorithm
that has been ported to Python.The software provided here runs using the Python interpreter.Application of ABC-MRT(16) to a speech communication system-under-test (SUT)
requires two steps.Pass a set of reference recordings through the SUT to produce a set
of test recordings.Apply ABC-MRT(16) to the test recordings to produce a success rates that
describe the intelligibility of the SUT.All of these steps are run by the intelligibility measurement software found athttps://github.com/usnistgov/intelligibility. Although it is possible to use
stand alone, the GUI available athttps://github.com/usnistgov/mcvqoeis also
recommended.References[1] S. Voran "Using articulation index band correlations to objectively
estimate speech intelligibility consistent with the modified rhyme test,"
Proc. 2013 IEEE Workshop on Applications of Signal Processing to Audio and
Acoustics, New Paltz, NY, October 20- 23, 2013. Available atwww.its.bldrdoc.gov/audioafter October 20, 2013.[2] S. Voran "A multiple bandwidth objective speech intelligibility
estimator based on articulation index band correlations and attention,"
Proc. 2017 IEEE International Conference on Acoustics, Speech, and
Signal Processing, New Orleans, March 5-9, 2017. Available atwww.its.bldrdoc.gov/audio.[3] ANSI S3.2, "American national standard method for measuring the
intelligibility of speech over communication systems," 1989.LegalNTIATHE NATIONAL TELECOMMUNICATIONS AND INFORMATION ADMINISTRATION, INSTITUTE
FOR TELECOMMUNICATION SCIENCES ("NTIA/ITS") DOES NOT MAKE ANY WARRANTY OF
ANY KIND, EXPRESS, IMPLIED OR STATUTORY, INCLUDING, WITHOUT LIMITATION,
THE IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
NON-INFRINGEMENT AND DATA ACCURACY. THIS SOFTWARE IS PROVIDED "AS IS."NTIA/ITS does not warrant or make any representations regarding the use of
the software or the results thereof, including but not limited to the
correctness, accuracy, reliability or usefulness of the software or the
results.You can use, copy, modify, and redistribute the NTIA/ITS developed
software upon your acceptance of these terms and conditions and upon your
express agreement to provide appropriate acknowledgments of NTIA's
ownership of and development of the software by keeping this exact text
present in any copied or derivative works.The user of this Software ("Collaborator") agrees to hold the U.S.
Government harmless and indemnifies the U.S. Government for all
liabilities, demands, damages, expenses, and losses arising out of
the use by the Collaborator, or any party acting on its behalf, of
NTIA/ITS' Software, or out of any use, sale, or other disposition by the
Collaborator, or others acting on its behalf, of products made
by the use of NTIA/ITS' Software.NISTThis software was developed by employees of the National Institute of Standards
and Technology (NIST), an agency of the Federal Government. Pursuant to title 17
United States Code Section 105, works of NIST employees are not subject to
copyright protection in the United States and are considered to be in the public
domain. Permission to freely use, copy, modify, and distribute this software and
its documentation without fee is hereby granted, provided that this notice and
disclaimer of warranty appears in all copies.THE SOFTWARE IS PROVIDED 'AS IS' WITHOUT ANY WARRANTY OF ANY KIND, EITHER
EXPRESSED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTY
THAT THE SOFTWARE WILL CONFORM TO SPECIFICATIONS, ANY IMPLIED WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND FREEDOM FROM INFRINGEMENT,
AND ANY WARRANTY THAT THE DOCUMENTATION WILL CONFORM TO THE SOFTWARE, OR ANY
WARRANTY THAT THE SOFTWARE WILL BE ERROR FREE. IN NO EVENT SHALL NIST BE LIABLE
FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO, DIRECT, INDIRECT, SPECIAL OR
CONSEQUENTIAL DAMAGES, ARISING OUT OF, RESULTING FROM, OR IN ANY WAY CONNECTED
WITH THIS SOFTWARE, WHETHER OR NOT BASED UPON WARRANTY, CONTRACT, TORT, OR
OTHERWISE, WHETHER OR NOT INJURY WAS SUSTAINED BY PERSONS OR PROPERTY OR
OTHERWISE, AND WHETHER OR NOT LOSS WAS SUSTAINED FROM, OR AROSE OUT OF THE
RESULTS OF, OR USE OF, THE SOFTWARE OR SERVICES PROVIDED HEREUNDER. |
abc-of-matrix-algebra | Portfolio Project - Simple Matrix AlgebraThis package computes basic matrix operations that include:Addition,Subtraction,Multiplication |
abconfig | ABConfigThe configuration should be simple, this project aims to give you all the power while maintaining ease of use.FeaturesJson or Yaml files and environment variables are supported as source;Correct data types (even for environment variables);Create configurations in django models style;The result object is a regular dictionary;Read the docsDocumentation:http://abconfig.readthedocs.io/Also strongly recommend that you read"The twelve-factor app" for configbefore starting. |
abcp-api-beta | Failed to fetch description. HTTP Status Code: 404 |
abcplus | No description available on PyPI. |
abcpmc | A Python Approximate Bayesian Computing (ABC) Population Monte Carlo (PMC) implementation based on Sequential Monte Carlo (SMC) with Particle Filtering techniques.Theabcpmcpackage has been developed at ETH Zurich in theSoftware Lab of the Cosmology Research Groupof theETH Institute of Astronomy.The development is coordinated onGitHuband contributions are welcome. The documentation ofabcpmcis available atreadthedocs.organd the package is distributed overPyPI.FeaturesEntirely implemented in Python and easy to extendFollows Beaumont et al. 2009 PMC algorithmParallelized with muliprocessing or message passing interface (MPI)Extendable with k-nearest neighbour (KNN) or optimal local covariance matrix (OLCM) pertubation kernels (Fillipi et al. 2012)Detailed examples in IPython notebooksA2D gausscase studyAMulti distancecase studyAtoy modelincluding a comparison to theoretical predictionsHistory0.1.2 (2016-01-27)Added support for sampling with multiple distance simultaneouslyClean setup.pySimplifying the codeImproved documentation0.1.1 (2015-05-03)Python 3 supportMinor fixesImproved documentation0.1.0 (2015-04-28)First release |
abc-property | Better Abstract Basic ClassesPython ABC with a simple @abstract_property decorated checked after instantiationEntirely based onthis StackOverflow answerbykrassowski.Example:from better_abc import BetterABC,abstract_property
class AbstractClassWithAbstractAttribute(BetterABC):
@abstract_property
def prop(self):
pass
otherprop = abstract_property()
class ClassWithProperty(AbstractClassWithAbstractAttribute)
def __init__(self,propvalue=12):
self.prop = 12
self.otherprop = "a string" |
abcpy | ABCpy is a highly modular, scientific library for approximate Bayesian computation (ABC) written in Python. It is designed to run all included ABC algorithms in parallel, either using multiple cores of a single computer or using an Apache Spark or MPI enabled cluster. The modularity helps domain scientists to easily apply ABC to their research without being ABC experts; using ABCpy they can easily run large parallel simulations without much knowledge about parallelization, even without much additional effort to parallelize their code. Further, ABCpy enables ABC experts to easily develop new inference schemes and evaluate them in a standardized environment, and to extend the library with new algorithms. These benefits come mainly from the modularity of ABCpy. |
abcpy1801 | test |
abc-radio-wrapper | ABC Radio WrapperAPI wrapper library for the song history of abc radio channelsFree software: MIT licenseDocumentation:https://abc-radio-wrapper.readthedocs.io.Quick Startimportabc_radio_wrapperABC=abc_radio_wrapper.ABCRadio()search_result=ABC.search(station="triplej")forradio_playinsearch_result.radio_songs:print(radio_play.song.title)forartistinradio_play.song.artists:print(artist.name)FeaturesUse python to search through the radio catalogue of triplej, ABC jazz, doublej and more!full type coverage for fast type hints on modern IDE’s>90% test coverageTODOPull out dataclasses into seperate class filesPull out unittests into seperate filesAdd async queriesCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2023-01-18)First added to githubFirst added to pypi0.1.1 (2023-01-21)Passing build on readthedocs0.1.2 (TBA)Add usage documentationAdd docstrings on all functions (pass pydocstyle audit)0.2.0 (TBA)Include iteration through search resultsInclude async requests0.3.0 (TBA)Add github actions for automatic testing1.0.0 (TBA) |
abcrypt-py | Python Bindings for abcryptabcrypt-pyis the Python bindings for theabcryptcrate.UsageInstallationTo install this library:pipinstallabcrypt-pyExamplefromtypingimportFinalimportabcrypt_pyDATA:Final[bytes]=b"Hello, world!\n"PASSPHRASE:Final[bytes]=b"passphrase"# Encrypt `DATA` using `PASSPHRASE`.ciphertext=abcrypt_py.encrypt(DATA,PASSPHRASE)assertciphertext!=DATA# And extract the Argon2 parameters from it.params=abcrypt_py.Params(ciphertext)assertparams.memory_cost==19456assertparams.time_cost==2assertparams.parallelism==1# And decrypt it back.plaintext=abcrypt_py.decrypt(ciphertext,PASSPHRASE)assertplaintext==DATADocumentationSee thedocumentationfor more details.Minimum supported Rust versionThe minimum supported Rust version (MSRV) of this library is v1.74.0.Developmentmaturinis required for development of this library.python3-mvenvvenvsourcevenv/bin/activate
maturindevelop
pip3installabcrypt-py[test,dev]ChangelogPlease seeCHANGELOG.adoc.ContributingPlease seeCONTRIBUTING.adoc.LicenseCopyright © 2022–2024 Shun Sakai (seeAUTHORS.adoc)This library is distributed under the terms of either theApache License 2.0or theMIT License.This project is compliant with version 3.0 of theREUSE Specification. See
copyright notices of individual files for more details on copyright and
licensing information. |
abcsarang1 | My first Python package with a slightly longer description |
abc-sphinx-extensions | ABC-Sphinx-ExtensionA sphinx extension to convert abc files into svg
images for use in a Sphinx document.It usesabcm2ps <http://moinejf.free.fr/>_, to carry out the conversion.To installFrom [email protected]:wxtim/abc-sphinx-extensions.git
pipinstall-e.From PyPipipinstallabc-sphinx-extensionsTo useAdd files with the extension.abcin source folder. After building these files will be available
asx.svg(with title rendered) and_x.svg(without title) for filex.abc. |
abc-storage | # abs-storage## InstallingBefore work with our storage, you need to install:sudo apt-get install docker.io make docker-composeMake and docker is not required features. This tools is needed for more useful development. We recommend to use Anaconda
or another environment manager for safety system interpreter. You can download Anaconda
[here](https://www.anaconda.com/). After installing Anaconda please create new environment:conda create –name abc-storage python=3.7
conda activate## StartingBefore starting please install all python package dependencies:make depsWe have three mode of starting:full subsystemdevelopmentmake### docker-compose fullWe use docker-compose for local development and starting you service and environment. If you want to start full
subsystem, you need to do this:make run-fullAfter that our service and environment is started. If you want to start our service the first time, docker container
with service is built. Other container is pulled.If you want to start service not first time, maybe you need rebuilt service for apply last changes:make run-rebuild### developmentFor development, you can use only environment:make run-envAfter that, it starts all dependencies services. Now, you can run our service in your IDE for development.### makeFor fast start our service we use command:make run## Environment variablesOur service takes all environments variables from config:deployments/.envs/local.env. More about it you can read into
this file:abc_storage/__service/config.py. You can add new variables there and here:deployments/.envs/local.env.We separates variables by namespaces, therefore we set prefix before variable name. You can see in files, which we
denote above.## TestingWe have three mode of testing:unit testingintegration testingall: unit and integration testingWe have three commands:make test-integrationBefore starting integration tests (above) you need to start environment:make run-envUnit tests:make test-unitAll tests:make test## NoticeWe use makefile as interface for communicate our application with our systems by command line while development and
deployments |
abctest | This is a very simple calculator that takes two numbers and either add, subtract, multiply or divide them.Change Log0.0.1 (19/04/2020)First Release |
abctoolwithpython | No description available on PyPI. |
abcunit-backend | Storage backends for an ABCUnit Framework, logging success and failures of process units.Database BackendTo use this backend you will need to contact the JASMIN help desk ([email protected]) and ask them to setup a postgresql database for you. Specify a name for the database and a username to login with. JASMIN support will get back to you with the user password and host name.After you have got your database, you’ll need to export an environment variable called$ABCUNIT_DB_SETTINGSand set it to a connection string forpsycopg2:ABCUNIT_DB_SETTINGS="dbname=<name> user=<user> host=<host> password=<pwd>"DatabaseHandlerclass construction looks like this:DatabaseHandler(table_name="results")Wheretable_nameis the name of the table logs will be insert intoConnects to an existing database and creates a table to store results:<table_name> (id varchar(255) PRIMARY KEY, result varchar(255) NOT NULL)idresultfacet1.facet2.facet3successfacet1.facet2.facet3bad_file⋮⋮File System BackendFileSystemHandlerclass construction looks like this:FileSytemHandler(base_log_dir, n_facets, sep)Where;base_log_diris the string path to top level directory for logsn_facetsis the number of facets used to describe each unit resultsepis the separator used for a result identifierUses the file system to create log files marking success and failures, categorised by directory structure:<log_base_dir>/success/facet1/facet2/facet3
<log_base_dir>/failure/error_type/facet1/facet2/facet3 |
abc-utils | abc-utilsUtility library to work with the recently published ABC dataset |
abcvoting | abcvotingDocumentationInstallationHow to cite the abcvoting libraryAcknowledgements and contributors► abcvoting web appA Python library of approval-based committee (ABC) rulesApproval-basedcommittee rules (ABC rules) are voting methods for selecting a committee, i.e., a fixed-size subset of candidates.
ABC rules are also known as approval-based multi-winner rules.
The input of such rules areapproval ballots.
We recommend the book
(Multi-Winner Voting with Approval Preferences)
by Lackner and Skowron [2] as a detailed introduction to ABC rules and related research directions.
In addition, thesurvey by Faliszewski et al.[1]
is useful as a more general introduction to committee voting (not limited to approval ballots).The following ABC rules are implemented:Approval Voting (AV)Satisfaction Approval Voting (SAV)Proportional Approval Voting (PAV)Sequential Proportional Approval Voting (seq-PAV)Reverse Sequential Proportional Approval Voting (revseq-PAV)Approval Chamberlin-Courant (CC)Phragmén's sequential ruleMonroe's ruleMinimax Approval Voting (MAV)Greedy MonroeMethod of Equal Shares (Rule X)Phragmén's First Method (Eneström's Method)and many more ...In addition, one can verify axiomatic properties such asJustified Representation (JR)Propotional Justified Representation (PJR)Extended Justified Representation (EJR)PriceabilityThe core propertyInstead of using the abcvoting Python library, you can also use theabcvoting web applicationby Dominik Peters.InstallationAs simple as:pipinstallabcvotingFurther details can be foundhere.DevelopmentInstall all dependencies including development requirements and the abcvoting package indevelopment mode:pipinstall-e.[dev]Basic unit tests can be run by excluding tests which require additional dependencies:pytest-m"not mipgurobi and not gmpy2 and not slow"tests/For development, configure the black formatter and pre-commit hooks - see below. Also installing
all optional dependencies is recommended.A development package is build for every commit on the master branch and uploaded to the test
instance of PyPI. It can be installed using the following command:python3-mpipinstall--index-urlhttps://test.pypi.org/simple/--extra-index-urlhttps://pypi.org/simpleabcvotingBlack formattingCode needs to be formatted using theblack formatter. This is
checked by Github actions.Configure your editorto run the
black formatter.Pre-commit hooksPre-commit hooks are not required, but they are recommended for development.Pre-commitis used to manage and maintain pre-commit hooks. Install
pre-commit (e.g. via apt, conda or pip) and then run$ pre-commit installto install the hooks.References[1] Piotr Faliszewski, Piotr Skowron, Arkadii Slinko, and Nimrod Talmon. Multiwinner voting: A
new challenge for social choice theory. In Ulle Endriss, editor, Trends in Computational Social
Choice, chapter 2, pages 27–47. AI Access, 2017.http://research.illc.uva.nl/COST-IC1205/BookDocs/Chapters/TrendsCOMSOC-02.pdf[2] Lackner, Martin, and Piotr Skowron. "Multi-Winner Voting with Approval Preferences".
Springer International Publishing, SpringerBriefs in Intelligent Systems , 2023.https://link.springer.com/book/10.1007/978-3-031-09016-5 |
abcXYZ | No description available on PyPI. |
abcyui | UNKNOWN |
abd | abd - Abstract Base Decoratorabd provides anAbstractBaseDecoratorclass which you can inherit from to create flexible decorators.Example>>>fromabdimportABD>>>classDecorator(ABD):...definvoke(self,*args,**kwargs):..."""Must write an invoke function... invoke is called when the decorated function is called... """...# catch, edit and pass on the (keyword) arguments...# that are given the the decorated function...print('invoke is called')...result=self.decorated_object(*args,**kwargs)...# function has been called and result is available...# possible to edit the result here...returnresult...>>>@Decorator...deffunc(argument):...# some function logic ......returnargument...>>>func('some text')invokeiscalled'some text'>>>PyPIpip install abd |
abdalla-dsnd-distributions | No description available on PyPI. |
abdalmjeedalhobany | No description available on PyPI. |
abdal-net-py | Abdal Net PyMade ForPowerful security network package for hackers and all security expertsRequires Libhurry.filesize - psutilRequires pythonPython >= 3.9Featurescalculate internet speed with unitcalculate byte to other unit (show in xbit vs xbyte )Convert byte to other unit by select unitmulti password generatorlog writer + logging ram and cpu usageiranian mobile phone generateHow To installpipinstallabdal-net-pyHow To upgradepipinstallabdal-net-py-UHow To useimportabdal_net_py❤️ DonationUSDT: TXLasexoQTjKMoWarikkfYRYWWXtbaVadBBTC : bc1q9w9ymgz2wluax60rsuza4q0at7gpy82g8el6zjETH : 0x402b9f67091Af07224286F16d7377bc50268Db94For Iranian People -> MellatBank : 6104-3378-5301-4247🤵 ProgrammerEbrahim Shafiei (EbraSha)E-Mail [email protected]:https://t.me/ProfShafieiLicenseAbdal Net Py is open-source software licensed under theMIT license.☠️ Reporting IssuesIf you are facing a configuration issue or something is not working as you expected to be, please use [email protected]. Issues on GitLab are also welcomed.⚠️ Legal disclaimer ⚠️Usage of Abdal Net Py for Spying targets without prior mutual consent is illegal. It's the end user's responsibility to obey all applicable local, state and federal laws. Developers assume no liability and are not responsible for any misuse or damage caused by this program. |
ab-data-processing | FeaturesData Processing is used for data processing through MinIO, databases, Web APIs, etc. The data types handled include:txtjsondochtmlexcelcsvpdfmarkdownpptText Type ProcessingThe data processing process includes: cleaning abnormal data, filtering, de-duplication, and anonymization. |
abDB | UNKNOWN |
abdbeam | Abdbeam : composites cross section analysisA Python package for the cross section analysis of composite material beams of any shape.Main featuresThese are a few things you can do withAbdbeam:Use a fast thin-walled anisotropic composite beam theory including closed cells, open branches, shear connectors and booms (discrete stiffeners containing axial and torsional stiffnesses);Recover replacement stiffnesses (EA, EIyy, EIzz, EIyz, GJ) and/or a full 4 x 4 stiffness matrix for beams with arbitrary layups and shapes;Recover centroid and shear center locations;Obtain internal load distributions (Nx, Nxy, Mx, My, Mxy for segments; Px and Tx for booms) for a large number of cross section load cases (defined by Px, My, Mz, Tz, Vy and Vz section loads);Plot cross sections, their properties and internal loads.InstallingInstall using PyPI (Python package index) :pipinstallabdbeamSource and DocumentationThe source code is hosted on GitHub athttps://github.com/victorazzo/abdbeamand the documentation can be found athttps://docs.abdbeam.org.DependenciesNumPyPandasMatplotlibExampleLet's useAbdbeamto analyze the cross section with two closed cells below:Start creating the section materials, its points and segments (we'll also calculate the section properties and request a summary at the end):importabdbeamasabsc=ab.Section()# Create a materials dictionary:mts=dict()mts[1]=ab.Laminate()ply_mat=ab.PlyMaterial(0.166666,148000,9650,4550,0.3)mts[1].ply_materials[1]=ply_matmts[1].plies=[[0,1]]*6+[[45,1]]*6# Create a points dictionary based on Y and Z point coordinates:pts=dict()pts[1]=ab.Point(0,-35)pts[2]=ab.Point(-50,-35)pts[3]=ab.Point(-50,35)pts[4]=ab.Point(0,35)pts[5]=ab.Point(50,35)pts[6]=ab.Point(50,-35)# Create a segments dictionary referencing point and material ids:sgs=dict()sgs[1]=ab.Segment(1,2,1)sgs[2]=ab.Segment(2,3,1)sgs[3]=ab.Segment(3,4,1)sgs[4]=ab.Segment(4,1,1)sgs[5]=ab.Segment(4,5,1)sgs[6]=ab.Segment(5,6,1)sgs[7]=ab.Segment(6,1,1)# Point the dictionaries to the sectionsc.materials=mtssc.points=ptssc.segments=sgs# Calculate and output section propertiessc.calculate_properties()sc.summary()Which prints:SectionSummary===============Numberofpoints:6Numberofsegments:7Numberofcells:2Centroid
--------yc=-2.67780636e-01zc=0.00000000e+00
ShearCenter
------------ys=2.35301214e-03zs=-1.45758049e-03
ReplacementStiffnesses
-----------------------EA=6.80329523e+07EIyy=5.24834340e+10EIzz=8.36408748e+10EIyz=0.00000000e+00GJ=1.23762317e+10EImax=8.36408748e+10EImin=5.24834340e+10Angle=0.00000000e+00[P_c]-BeamStiffnessMatrixattheCentroid
---------------------------------------------[[6.80329523e+070.00000000e+002.46320132e+05-1.43701515e+08][0.00000000e+005.24834340e+100.00000000e+000.00000000e+00][2.46320132e+050.00000000e+008.36408748e+10-2.12142163e+07][-1.43701515e+080.00000000e+00-2.12142163e+071.23762317e+10]][W_c]-BeamComplianceMatrixattheCentroid
----------------------------------------------[[1.50683149e-080.00000000e+001.66286490e-281.74959530e-10][0.00000000e+001.90536313e-110.00000000e+000.00000000e+00][1.57282135e-250.00000000e+001.19558821e-112.04936911e-14][1.74959530e-100.00000000e+002.04936911e-148.28315446e-11]][P]-BeamStiffnessMatrixattheOrigin
-----------------------------------------[[6.80329523e+070.00000000e+00-1.79715871e+07-1.43701515e+08][0.00000000e+005.24834340e+100.00000000e+000.00000000e+00][-1.79715871e+070.00000000e+008.36456213e+101.72662667e+07][-1.43701515e+080.00000000e+001.72662667e+071.23762317e+10]][W]-BeamComplianceMatrixattheOrigin
------------------------------------------[[1.50691722e-080.00000000e+003.20155371e-121.74965018e-10][0.00000000e+001.90536313e-110.00000000e+000.00000000e+00][3.20155371e-120.00000000e+001.19558821e-112.04936911e-14][1.74965018e-100.00000000e+002.04936911e-148.28315446e-11]]Now let's create two load cases (101 and 102) and calculate their internal loads:sc.loads=dict()sc.loads[101]=ab.Load(My=5e6)sc.loads[102]=ab.Load(Tx=250000,Vz=5000.0)sc.calculate_internal_loads()Next print all internal loads (which outputs a lot of data we'll not show here):sc.print_internal_loads()Or access the Pandas dataframe containing these internal loads directly:df=sc.sgs_int_lds_dfNext plot the cross section and its properties (we'll show the segment orientations, hide legends, change the centroid , shear center and principal axis colors and use a custom figure size):ab.plot_section(sc,segment_coord=True,title='Abdbeam - Example',legend=False,prop_color='#471365',figsize=(5.12,3.84))Finally, plot Nx and Nxy for load case 101 (we'll change the matplotlib contour palette, reduce the internal load diagram scale, and use a custom figure size):ab.plot_section_loads(sc,101,contour_color='viridis',diagram_scale=0.7,int_load_list=['Nx','Nxy'],figsize=(5.12,3.84))LicenseBSD-3ContributeAbdbeamis at its early development stages and we encourage you to pitch in andcontribute on GitHub. Guidelines for contributors are in the works, so stay tuned.TheoryFor the theory behind Abdbeam, the most complete reference is:Victorazzo DS, De Jesus A. A Kollár and Pluzsik anisotropic composite beam theory for arbitrary multicelled cross sections. Journal of Reinforced Plastics and Composites. 2016 Dec;35(23):1696-711.These are also great references on its originating theory:Kollár LP, Springer GS. Mechanics of composite structures. Cambridge university press; 2003 Feb 17.Kollár LP and Pluzsik A. Analysis of thin-walled composite beams with arbitrary layup. J Reinf Plast Compos 2002; 21: 1423–1465.Note: the effects of shear deformation and restrained warping are assumed negligible inAbdbeam. Check the references above for more details. |
abd-clam | CLAM: Clustered Learning of Approximate Manifolds (v0.22.3)CLAM is a Rust/Python library for learning approximate manifolds from data.
It is designed to be fast, memory-efficient, easy to use, and scalable for big data applications.CLAM provides utilities for fast search (CAKES) and anomaly detection (CHAODA).As of writing this document, the project is still in a pre-1.0 state.
This means that the API is not yet stable and breaking changes may occur frequently.Installation>python3-mpipinstall"abd_clam==0.22.3"Usagefromabd_clam.searchimportCAKESfromabd_clam.utilsimportsynthetic_data# Get the data.data,_=synthetic_data.bullseye()# data is a numpy.ndarray in this case but it could just as easily be a# numpy.memmap if your data do fit in RAM. We used numpy memmaps for the# research, though they impose file-IO costs.model=CAKES(data,'euclidean')# The CAKES class provides the functionality described in our# [CHESS paper](https://arxiv.org/abs/1908.08551).model.build(max_depth=50)# Build the search tree to depth of 50.# This method can be called again with a higher depth, if needed.query,radius,k=data[0],0.5,10rnn_results=model.rnn_search(query,radius)# This is how we perform ranged nearest neighbors search with radius 0.5 around# the query.knn_results=model.knn_search(query,k)# This is how we perform k-nearest neighbors search for the 10 nearest neighbors# of the query.# The results are returned as a dictionary whose keys are indices into the data# array and whose values are the distance to the query.LicenseMITCitationTODO |
abdcon | This library can be installed using command " pip install electricalpy "it contains various functions such as
1.series
2.parallel
3.to_polar
4.to_rectangular
5.to_star
6.to_deltathey perfom the operation of conversion from one format. The input and output data types for above mentioned functions
is of type " List " |
ab-decrypt | Decryptor for android backups that were created withadb backup.Installationpython3-mvenv/path/to/venv/path/to/venv/pipinstallab-decryptln-sr/path/to/venv/ab-decrypt~/bin/Usage# Read from stdin, write to stdout$ab-decrypt# Read from stdin, write to stdout$ab-decrypt--# Read from file, write to other file$ab-decryptbackup.abbackup.tar# List backup contents$ab-decryptbackup.ab|tar-tvEnvironment variablesAB_DECRYPT_PASSWORD: Decryption passwordHelp / Bugs / ContributionsPlease file an issue or pull request at GitHub. |