package
stringlengths 1
122
| pacakge-description
stringlengths 0
1.3M
|
|---|---|
aa-taskmonitor | Task MonitorAn Alliance Auth app for monitoring celery tasks.ContentsFeaturesScreenshotsInstallationCommand line utilitySettingsFAQChange LogFeaturesTask Monitor enables administrators to monitor celery tasks running on their system.Creates a log of all recently executed celery tasks including failed and retried tasks.Stores many details in task logs to support the analysis of potential celery issues, including the parameters a task with called with and complete exception messagesKeeps the storage needs in check by automatically deleting older task logs and removing likely bloat from the collected data (but can also be turned off)Admins can investigate task log with search & filtersAdmins can view details for each task log incl. exceptions and trace logsAdmins can review reports with charts providing answers to common questions, e.g:How many tasks have failed/retried?How many tasks where run by each of my apps?Which are the most frequent tasks?Which tasks have the longest runtime?Which tasks failed the most?How much backlog do I have in task queue over time?Admins can export all task logs to a CSV file for further analysis with 3rd party tools (e.g. Google sheets)Admins can see detailed statistics for all tasksCommand line utility to manage task logs and queue directlyScreenshotsFull log of all recently executed tasksView details for each task incl. exception tracelogsExample chart in reportsView detailed statistics for all tasksInstallationStep 1 - Check prerequisitesTask Monitor is a plugin for Alliance Auth. If you don't have Alliance Auth running already, please install it first before proceeding. (see the officialAA installation guidefor details)Step 2 - Install appMake sure you are in the virtual environment (venv) of your Alliance Auth installation. Then install the newest release from PyPI:pipinstallaa-taskmonitorStep 3 - Configure Auth settingsConfigure your Auth settings (local.py) as follows:Add'taskmonitor'toINSTALLED_APPSOptional: Add additional settings if you want to change any defaults. SeeSettingsfor the full list.Step 4 - Finalize App installationRun migrations & copy static filespythonmanage.pymigrate
pythonmanage.pycollectstatic--noinputRestart your supervisor services for Auth.Command line utilityYou can manage your logs and queue also directly via a command line utility.The basic syntax for using the utility is:pythonmanage.pytaskmonitorctl{command}{target}For example you can inspect your logs with:pythonmanage.pytaskmonitorctlinspectlogsOr for example you can purge your task queue with:pythonmanage.pytaskmonitorctlpurgequeueTo get an overview of available commands run:pythonmanage.pytaskmonitorctl--helpTo get an overview of available targets for a command run:pythonmanage.pytaskmonitorctlinspect--helpSettingsHere is a list of available settings for this app. They can be configured by adding them to your AA settings file (local.py).Note that all settings are optional and the app will use the documented default settings if they are not used.NameDescriptionDefaultTASKMONITOR_APP_NAME_MAPPING_CONFIGAbility to map tasks to the same app name. Map must be a dictionary with string keys and list of strings as value. All app names in the list will be replaced by it's key.{}TASKMONITOR_DATA_MAX_AGEMax age of logged tasks in hours. Older logs be deleted automatically.24TASKMONITOR_DELETE_STALE_BATCH_SIZESize of task logs deleted together in one batch.5000TASKMONITOR_ENABLEDGlobal switch to enable/disable task monitor.TrueTASKMONITOR_HOUSEKEEPING_FREQUENCYFrequency of house keeping runs in minutes.30TASKMONITOR_QUEUED_TASKS_ADMIN_LIMITThe admin page will stop showing the list of queued tasks above this limit to protect against crashing caused by too high memory consumption.100000TASKMONITOR_QUEUED_TASKS_CACHE_TIMEOUTTimeout for caching queued tasks in seconds. 0 will deactivate the cache.10TASKMONITOR_REPORTS_MAX_AGEMax age of cached reports in minutes.60TASKMONITOR_REPORTS_MAX_TOPMax items to show in the top reports. e.g. 10 will shop the top ten items.20TASKMONITOR_TRUNCATE_NESTED_DATAWhether deeply nested task params and results are truncated.TrueFAQIs it possible to store task logs longer then for just 24 hours?Yes, there is a setting, which you can increase according to your needs. However, please keep in mind that your storage needs will increase accordingly. The current approx. usage is 0.5 KB per entry, so e.g. you need approx. 500 MB to store 1.000.000 task logs. Note that you can use the command line utility to find out how much space your logs are currently using.How is this app different from celery analytics?Celery Analytics seams to be designed mainly as data source for reports on Grafana. It apparently works great if you want to integrate analysis about your task executions into a Grafana dashboards. But it's usability without Grafana is limited.Task Monitor on the other hand aims to be fully functional standalone by providing reports and many useful features for analyzing your task logs directly on the admin site. It also provides a more complete picture, since Celery Analytics ignores retried tasks.How is this app different from celery's flower?Flower offers more detailed and technical information about task runs and might therefore be more most for developers. However, it not designed to store a larger number of task logs (default is only 10K) and is appears therefore to be less suited for Alliance Auth, where you typically have 100K+ tasks per day.What does data truncating do exactly?Task Monitor has data truncating enabled by default. It is applied when storing args, kwargs and results in task logs. This helps to reduce the storage consumptions and also makes the task log better readable. But it can be turned off.Task args are truncated by clearing all nested containers.Example:[1, [2, 3], 4]becomes[1, [], 4]Task kwargs are truncated by clearing all nested containers in values.Example:{"a": [1, 2], "b": 3}becomes{"a": [], "b": 3}Finally, task results are truncated like args and kwargs depending on their type. In addition lists of empty containers are compressed.Example:[ [], [], [] ]becomes[] |
aat-downloader | AAT DownloaderA package that helps download mobile AAT data.Installpip install aat_downloaderHow to useTo use this package, first download the google-services.json file from the settings of your Firebase realtime database.Downloading dataTo download data run the lines below (replace "experiment" with the experiment you want to delete).fromaat_downloader.downloaderimportDownloader# Initiate downloader with path to google services file (downloaded from Firebase)downloader=Downloader("data/external/google-services.json")The autoreload extension is already loaded. To reload it, use:
%reload_ext autoreload# Specify experiment name and storage folder and download datadownloader.download("experiment","data/raw")Deleting dataTo delete data run the following function (replace "experiment" with the experiment you want to delete).downloader.delete_participants("experiment")Warning: Are you sure you want to delete participants of experiment: fooddemo?
y |
aa-theme-console | Alliance Auth Theme: ConsoleAlliance Auth Theme: ConsoleInstallationThe perfect theme for all old school console nerds out there :-)Installationpipinstallaa-theme-consoleNow open yourlocal.pyand add the following right below yourINSTALLED_APPS:# Console Thame - https://github.com/ppfeufer/aa-theme-consoleINSTALLED_APPS.insert(0,"aa_theme_console")ImportantIf you are usingAA-GDPR, the template stuff needs to beaftertheAA_GDPRentry, like this:# GDPR ComplianceINSTALLED_APPS.insert(0,"aagdpr")AVOID_CDN=True# Console Thame - https://github.com/ppfeufer/aa-theme-consoleINSTALLED_APPS.insert(0,"aa_theme_console") |
aa-theme-slate | Alliance Auth Theme: SlateThis is theBootstrap theme Slateconverted into
a theme for Alliance auth.Alliance Auth Theme: SlateInstallationInstallationpipinstallaa-theme-slateNow open yourlocal.pyand add the following right below yourINSTALLED_APPS:# Slate Thame - https://github.com/ppfeufer/aa-theme-slateINSTALLED_APPS.insert(0,"aa_theme_slate")ImportantIf you are usingAA-GDPR, the template stuff needs to beaftertheAA_GDPRentry, like this:# GDPR ComplianceINSTALLED_APPS.insert(0,"aagdpr")AVOID_CDN=True# Slate Thame - https://github.com/ppfeufer/aa-theme-slateINSTALLED_APPS.insert(0,"aa_theme_slate") |
aa-timezones | AA Time ZonesApp for displaying different time zones with Alliance AuthAA Time ZonesInstallationStep 1: Install the AppStep 2: Update Your Alliance Auth SettingsStep 3: Finalizing the Installation(Optional) Public ViewsUpdatingConfigure the Timezone PanelsAdjusting TimeDiscord Bot CommandChangelogTranslation StatusContributingInstallationImportant: This app is a plugin for Alliance Auth. If you don't have
Alliance Auth running already, please install it first before proceeding.
(See the officialAA installation guidefor details)NoteThis app makes use of a feature introduced with Alliance Auth v3.6.1, meaning,
installing this app will pull in Alliance Auth v3.6.1 unsupervised if you haven't
updated yet.Please make sure to update Allianceauth to version 3.6.1 or higher before you
install this app to avoid any complications.Step 1: Install the AppMake sure you're in the virtual environment (venv) of your Alliance Auth installation.
Then install the latest version:pipinstallaa-timezonesStep 2: Update Your Alliance Auth SettingsConfigure your AA settings (local.py) as follows:Add'timezones',toINSTALLED_APPSStep 3: Finalizing the InstallationRun migrations & copy static filespythonmanage.pycollectstatic
pythonmanage.pymigrateRestart your supervisor services for AAOnce done, it's time to add all the time zone information, so you can define your
own set of panels later. To do so, simply run:pythonmanage.pytimezones_load_tz_data(Optional) Public ViewsThis app supports AA's feature of public views, since time zones conversion is not
any mission-critical information. To allow users to view the time zone conversion page
without the need to log in, please add"timezones",to the list ofAPPS_WITH_PUBLIC_VIEWSin yourlocal.py:# By default, apps are prevented from having public views for security reasons.# To allow specific apps to have public views, add them to APPS_WITH_PUBLIC_VIEWS# » The format is the same as in INSTALLED_APPS# » The app developer must also explicitly allow public views for their appAPPS_WITH_PUBLIC_VIEWS=["timezones",# https://github.com/ppfeufer/aa-timezones]NoteIf you don't have a list forAPPS_WITH_PUBLIC_VIEWSyet, then add the whole
block from here. This feature has been added in Alliance Auth v3.6.0 so you
might not yet have this list in yourlocal.py.UpdatingTo update your existing installation of AA Time Zones, first enable your virtual
environment.Then run the following commands from your AA project directory (the one that
containsmanage.py).pipinstall-Uaa-timezonespythonmanage.pycollectstaticpythonmanage.pymigrateNow restart your AA supervisor services.Configure the Timezone PanelsPer default, there are 10 additional time zone panels that are displayed (see first
image). If you want to change those, you can create your own set of panels in your
admin backend.NOTE:"Local Time" and "EVE Time" will always be displayed as the first two panels,
no matter what.Adjusting TimeYou can easily adjust the time that is displayed for all timezones. This is useful
for reinforcement timers or pre-planned fleets. To do so, click on the "Adjust Time"
button below the time zone panels, and you will see 2 different ways to set a new time.The first one is meant for timers, like reinforcement timers, anchoring timers or
the like. Its maximum is 7 days, 59 minutes and 59 seconds into the future. That
should cover pretty much all timers you can find in Eve Online.The second one is best suited for pre-planned fleets. Here you can set a fixed date
and time based on the selected time zone. The default selected time zone is "EVE
Time" but you can change it to all the available options. Keep in mind the selected
time zone is the one the time and date will be adjusted to. So if you are going to
use it to plan fleets, it is recommended to keep this set to "EVE Time".To set the adjusted time, simply click on "Set Time" in the row you altered. This
will then adjust all time zone panels to the time you selected and will also alter
the link in your browser, so you can share it with others directly.Discord Bot CommandFor this to work, you'll need to haveallianceauth-discordbotinstalled, configured
and running.(See this link)CommandEffect/timeShows the current Eve time and what time it is in theconfigured time zonesChangelogSeeCHANGELOG.mdTranslation StatusDo you want to help translate this app into your language or improve the existing
translation? -Join our team of translators!ContributingDo you want to contribute to this project? That's cool!Please make sure to read theContribution Guidelines.(I promise, it's not much, just some basics) |
aat-koala | Failed to fetch description. HTTP Status Code: 404 |
aa-toolbox | aa-toolbox: Toolbox for anticipatory actionTheanticipatory action(AA) toolbox is a Python package to support development of AA frameworks, by
simplifying the downloading and processing of commonly used datasets.The datasets that we currently support are:CHIRPS rainfallCOD ABs (Common Operational Datasets administrative boundaries)FEWS NET food insecurityGloFAS river dischargeIRI seasonal rainfall forecastUSGS NDVI (normalized difference vegetation index)For more information, please see thedocumentation.InstallingInstall and update usingpip:pipinstall-Uaa-toolboxA Simple ExampleDownload the admin boundary CODs for Nepal, and retrieve provinces
as a GeoDataFrame:fromaatoolboximportcreate_country_config,CodABcountry_config=create_country_config('npl')codab=CodAB(country_config=country_config)codab.download()provinces=codab.load(admin_level=1)ContributingFor guidance on setting up a development environment, see thecontributing guidelinesLinksDocumentationChangesPyPI ReleasesSource CodeIssue Tracker |
aatools | aatoolsInstallYou can install the package from Pypi using,pipinstallaatoolsor, if you prefer conda with,condainstall-crcvalenzuelaaatoolsHow to useCurrently the package only provides one functionplot_univariate_continuouswhich given a sample of data from a univariate random variable generates
the histogram and adds information on the mean and the quartilesLook at thedocumentationof
the package for information on how to use. |
aa-top | AA "Top"System Utilization and AA Statistics plugin forAlliance Auth.Inspired byhttps://zkillboard.com/ztop/by Squizz CaphinatorFeaturesResource Monitor
Celery Jobs in QueueDiff of last updatePlanned FeaturesInstallationStep 2 - Install apppipinstallaa-topStep 3 - Configure Auth settingsConfigure your Auth settings (local.py) as follows:Add'top'toINSTALLED_APPSAdd below lines to your settings file:## Settings for AA-Top# Update aatop.txtCELERYBEAT_SCHEDULE['top_update_aa_top_txt']={'task':'top.tasks.update_aa_top_txt','schedule':crontab(minute='*'),}Step 4 - Maintain Alliance AuthRun migrationspython manage.py migrateGather your staticfilespython manage.py collectstaticRestart your projectsupervisorctl restart myauth:Add file permissionssetfacl -m u:allianceserver:rw /var/www/myauth/static/top/aatop.txtPermissionsPermAdmin SitePermDescriptionbasic_accessnillCan access the web view for this appSettingsNameDescriptionDefaultContributingMake sure you have signed theLicense Agreementby logging in athttps://developers.eveonline.combefore submitting any pull requests. All bug fixes or features must not include extra superfluous formatting changes. |
aat-poc | No description available on PyPI. |
aatree | UNKNOWN |
aats | Apifiny Algo Trading SystemAATS is a light weight trading system with low-latency and high-scalability for Live trading on multi-crypto exchanges.Key FeaturesLight weight: you only need to take care of your strategy component and you can trade alive!Low latency: the low-level system is optimizied by C++, such as exchange connectivity, order book management and order placementHigh flexibility: with raw tick data and quote data, you can freely build samplers, pricing models, variables and signals on your own into your strategyDistributed broadcast: You can only start one market instance and connect to multiple trading instancesQuick StartThis quick start gives you all the steps that you need to do before start trading.Install dockerPlease download and install Docker CE or Docker Desktop for your computer/server if it isn't installed:MacWindowsLinuxGet and run the Algo SDK docker image using the following command:docker run -it apifinyalgo/algo-sdk:1.1.0his step will automatically run control server which will be used to start market/trading instance later. Depending on system, you may need to run this with sudo.TBA: how to check if it is running, i.e. ps commandInstall aats package# install stable version from pip (support python version >=3.7)
pip install aats (TBA: currently pip install -i https://test.pypi.org/simple/ aats)
# clone the repository with latest version
git clone http://git.ddesk.io/exone-plus/algo-client-api.git (TBA: replace with public repo link)Maintain your unique cid symbol mapping tableIt requires to be consistent in both market engine and trade enginesym_cid_map = {
1001: "BTCUSDT.BINANCE",
1002: "ETHUSDT.BINANCE",
1003: "DOGEUSDT.BINANCE",
1004: "BTCUSDTSWAP.BINANCE_SWAP"
}Start market instance to listen subscribed symbols and exchangesTBA: change the below to one command line to start market instancefrom aats.market_engine import MarketEngine
# start market engine
mkt_engine = MarketEngine(sym_cid_map)
mkt_engine.set_control_server(6000) # default control server port
mkt_engine.set_multicast_cfg('239.0.0.4', 4141)
# mkt_engine.add_listen_symbol('BTCUSDT', 'BINANCE', 5)
# mkt_engine.add_listen_symbol('ETHUSDT', 'BINANCE', 5)
mkt_engine.add_listen_symbol('DOGEUSDT', 'BINANCE', 5)
mkt_engine.add_listen_symbol('BTCUSDTSWAP', 'BINANCE_SWAP', 5)
mkt_engine.run()Once console returns the following message, it means market instance is running successfully{'result': 'ok', 'type': 'market_instance'}Write your strategy and ready to tradeIn the examples folder, we provide two sample strategies and demo_main.py script which illustrates how to setup config and run strategySimpleTakerStrategy: it is a naive taker strategy, place order on a fixed time intervalSimpleMakerStrategy: it is a bit complicated maker strategy with order management system##############################################
# Demo strategy #
##############################################
import time
from aats.trade_engine import TradeEngine
from simple_maker_strategy import SimpleMakerStrategy
from simple_taker_strategy import SimpleTakerStrategy
sym_cid_map = {
1001: "BTCUSDT.BINANCE",
1002: "DOGEUSDT.BINANCE"
}
# init trade engine
trade_engine = TradeEngine(sym_cid_map)
# setup public config
trade_engine.set_md_multicast_cfg(send_to_ip='239.0.0.3', send_to_port=4141)
trade_engine.add_md_symbol(symbol='BTCUSDT', exchange='BINANCE')
# trade_engine.add_md_symbol(symbol='DOGEUSDT', exchange='BINANCE')
# setup private config
trade_engine.set_control_server(server_port=6000)
trade_engine.config_exchange(exchange='BINANCE', trade_type='sandbox')
trade_engine.set_apikey(exchange="BINANCE",
key="02SvhZEYG1p92JWdekP75XQKayqfLxmjHWNEfWU1KrCPjJ5xrLcOU1YHZ5SUBVFA",
secret="iKnZvDKMGQuEINhjDX8gbIVJDLl48fV6GFLL5gcFT8Sfj9yxGrnP7uFm7AAVWeFP",
password="",
subaccount="")
trade_engine.set_fee('BINANCE', 0.0003, 0)
trade_engine.add_trade_symbol(symbol='BTCUSDT', exchange='BINANCE')
# setup your strategy
# my_strategy = SimpleMakerStrategy()
my_strategy = SimpleTakerStrategy(msecs=10000)
trade_engine.add_strategy(my_strategy)
# start run
try:
trade_engine.run()
except KeyboardInterrupt as err:
# trade_engine.stop()
print("close strategy and close open orders")
# trade_engine.manager.stop()
my_strategy.close()
time.sleep(1)
print("trade closed") |
aautilitypackage | No description available on PyPI. |
aa-utility-package | No description available on PyPI. |
aautt | Failed to fetch description. HTTP Status Code: 404 |
aave-python | Aave V2 DeFi Client for Web3.pyNOTE: This is the beta version of the client. More docs to come...Overview:The Aave V2 DeFi Client is a Python wrapper for the core functionality on the Aave V2 DeFi lending protocol built using only two 3rd party packages, web3 and requests.Currently only theEthereum mainnetandKovan testnetare supported.SetupEnsure that you are using Python version 3.9+Install the package using pip:pipinstallaave-pythonRepare your HTTP providers for the Ethereum mainnet and/or Kovan testnet.Usage:You can find examples for the client's functionality in theusage_examplesdirectory.How to Get Kovan Testnet WETH:Enter your public wallet address atethdrop.devand get ETHUse theusage_examples/get_kovan_weth.pyscript to convert your testnet ETH to ERC-20 WETH that can be deposited to Aave. |
aavrugtest | No description available on PyPI. |
aav.upcoming-games | upcoming-gamesReddit bot to update sidebar for /r/IGN. Can be configured for a variety
of uses.UsageInstall Python 3.6 or greater if you have not already.Install the bot withpip installaav.upcoming-games. You may need
to usesudoorpip3or--userdepending on your
permissions, i.e. if you do not have sudo permissions and you also
have Python 2 installed, you may need to usepip3 install--useraav.upcoming-games.Obtain a Reddit client ID and client secret fromhttps://reddit.com/prefs/appson the account you want to use for the
bot.Set up your configuration file and template as mentioned in the
‘Configuration’ section.Run the bot from the command line with the full path to your config
file:upcoming-games"/home/aav/my.yaml"Developer UsageInstall Python 3.6 or greater if you have not already.Install the bot withpip installaav.upcoming-games. You may need
to usesudoorpip3or--userdepending on your
permissions, i.e. if you do not have sudo permissions and you also
have Python 2 installed, you may need to usepip3 install--useraav.upcoming-games.import upcoming_gamesYou can use any of the three functions:get_all_games,get_markdown,post_table, and the classUpcomingGameas
desired.ConfigurationHere is the default configuration file:general:silent:Falsetime_period:"7d"systems:[]game_limit:10table_format:"short"reddit:client_id:"..."client_secret:"..."subreddit:"..."scripthost:"..."password:"..."post_type:"sidebar"template:'path/to/template.txt'Here’s what each setting is for:generalsilent- True if you don’t want any script output.time_period- Valid time period for upcoming games (can be one
of7d, 1m, 3m, 6m, 12m, all).system- List of consoles you want to include releases for.
Empty means include all.game_limit- Number of games you want for the Markdown table.table_format-shortfor only the game name and first
release,longfor system details.redditclient_id- Your reddit bot’s client ID.client_secret- Your reddit bot’s client secret.subreddit- The subreddit (your must be a moderator) to post
to/update the sidebar.scripthost- The username for the bot account you registered
for the client ID on.password- The password for the bot account.post_type-sidebarto update the sidebar,stickyto
make a ‘bottom’ stickied post.template- the full path to the template you want to use.Note the template must contain somewhere in it the text %%%TABLE%%%, as
this is where the Markdown table will be put. If no path or an invalid
path is specified, the template used will be blank, i.e. it will only
contain the Markdown table, nothing else. |
aawscd | aawscd: Utilities for the Aaware Sound Capture platform |
aaxenforo2 | AA-XenForo2XenForo v2.x Service Module forAlliance AuthContentsOverviewFeaturesInstallationStep 1 - Install the packageStep 2 - Configure Alliance AuthStep 3 - Finalize the installationStep 4 - Preload Eve Universe dataStep 5 - Set up permissionsStep 6 - (Optional) Import from built-in SRP modulePermissionsSettingsOverviewFeaturesIntegration with XenForo v2.x Forum Software as a user managerInstallationImportant: Please make sure you meet all preconditions before you proceed:AA XenForo2 is a plugin for Alliance Auth. If you don't have Alliance Auth running
already, please install it first before proceeding. (see the officialAA installation guidefor details)Step 1 - Install the packageMake sure you are in the virtual environment (venv) of your Alliance Auth
installation Then install the latest release directly from PyPi.pipinstallaaxenforo2Step 2 - Configure Alliance AuthThis is fairly simple, just add the following to theINSTALLED_APPSof yourlocal.pyConfigure your AA settings (local.py) as follows:Add"aaxenforo2",toINSTALLED_APPSStep 3 - Finalize the installationRun migrationspythonmanage.pymigrateRestart your supervisor services for AuthStep 4 - Set up permissionsNow it's time to set up access permissions for your new forum service. You can do so in
your admin backend in the AA XenForo2 section. Read thePermissionssection for more information about the available permissions.PermissionsIDDescriptionNotesaccess_xenforo2Can access the XenForo2 Service PageYour line members should have this permission.SettingsKeyDescriptionTypeDefaultExampleAAXENFORO2_ENDPOINTThe full web address to the xenforo2 install. Must include protocol (https://) and trailing slash/stringNonehttps://forums.mysite.com/AAXENFORO2_APIKEYXenForo2 Api Key, Must be a superuser keystringNonedefault_api_key_valueAAXENFORO2_API_USER_IDXenForo User ID of an admin to act with via the APIintNone1AAXENFORO2_DEFAULT_GROUPXenForo Group ID to add users to by defaultintNone5AAXENFORO2_EXTRA_GROUPXenForo Group ID to add users to in addition to their main groupstringNone"6" |
aaxxww2121 | No description available on PyPI. |
aaypyutil | AAYPYUTILCommon python util functionsInstallationpip install aaypyutilInfolog_utilconfigure_loggerfunc_utilretry_on_exceptiondecoratorMaintainerⓘAayush Uppal |
aayush1607-vm | Failed to fetch description. HTTP Status Code: 404 |
aayush-color | aayush-colorA simple python program to convert a color format to another color format.Use the package in your projectInstall the packagepip install aayush-colorUsing the packageimport aayush_color.color as color
color.hex_to_rgb("#ffffff")Aayush Nagpal © 2023NoteThis is for a university project. Might not be maintained in future. |
aayush-distributions | No description available on PyPI. |
aayushpdf | No description available on PyPI. |
aayushSample | aayushSampleLearning purposeNew Features!There is 1function written in this packageFunctions:import aayushSample as a
fun1() :prints life changing quote
# Output will reflect on terminalInstallationpip install aayushSampleYou can reach out me at,[email protected] |
aaz-dev | Microsoft Atomic Azure CLI Dev ToolsTheaaz-devtool is designed to generate atomic Azure CLI commands from OpenAPI specifications. For more information, please refer todocumentandvideo.InstallationCurrently, we can install it with a.whl file. Later on, we'll publish it to PyPI to supportpip installway of installation.Setting up your development environment1 Code reposPleaseForkthe following repos in your github account andClonethem in your local disk:Azure CLIAzure CLI ExtensionAAZ: Used to upload the command model generated.azure-rest-api-specsorazure-rest-api-specs-prAfter clone you can addupstreamfor every repos in your local clone by usinggit remote add upstream.2 Setup python2.1 Install pythonPlease install python with version >= 3.8 in your local machine.For windows: You can download and run full installer fromPython Download.For linux: You can install python from Package Manager or build a stable relase from source codeCheck the version of python, make use it's not less than 3.8.For windows:
You can run:C:\Users\{xxxx}\AppData\Local\Programs\Python\Python3{xxxx}\python--versionC:\Users\{xxxx}\AppData\Local\Programs\Python\Python3{xxxx}is the python installation path.For linux:python--versionYou can also specify the version number when you have multiple versions installed. For example if you want to run version 3.8python3.8--version2.2 Setup a python virtual environmentYou can use venv to create virtual environments, optionally isolated from system site directories. Each virtual environment has its own Python binary (which matches the version of the binary that was used to create this environment) and can have its own independent set of installed Python packages in its site directories.You can run the following command to create a new virtual environment:For windows:C:\Users\{xxxx}\AppData\Local\Programs\Python\Python3{xxxx}\python-mvenv{somepath}\{venvname}For linux:python3.8-mvenv{somepath}/{venvname}3 Active existing virtual environmentYou shouldalwaysactive the virtual environment for azure-cli development.For Windows:Powershell{somepath}\{venvname}\Scripts\Activate.ps1Command Prompt{some path}\{venv name}\Scripts\activate.batFor Linux:source{somepath}/{venvname}/bin/activateAfter active the virtual environment, thepythoncommand will always be the one creates this virtual environment and you can always usepythonpython --version4 Install tools for azure-cli development4.1 Installazure-cli-dev-toolsBoth for windows and linuxpip install azdev4.2 Install aaz-dev-toolsFor WindowsPowershellpip install aaz-devCommand Promptpip install aaz-devFor linuxpipinstallaaz-dev4.3 Set up build envFor linux users, set up python3 build tools would avoid other unseen installation issuesUbuntu: apt-get install python3-dev build-essential
Centos: yum install python3-devel4.4 Possible problemsFor windows users, dependency python-levenshtein installation might run into trouble. developers might need to download.whlfile and install it manually (reference tolink)5. Code repos setup5.1 azure-cliBefore start to the development task, you should always sync the code in thedevbranch ofupstream(Azure/Azure-cli).
If your commands will generated to azure-cli repo, you should checkout a new branch withfeature-prefix.5.2 azure-cli-extensionsIf your commands will generated to azure-cli-extension repo, you should sync the code in themainbranch ofupstream(Azure/Azure-cli-extensions), and checkout a new branch withfeature-prefix.5.3 aazBefore start to the development task, you should always sync the change in themainbranch ofupstream, and checkout a new branch withfeature-prefix.5.4 runazdev setupYou should always run the following command everytime you syncazure-clicode ofupstream.azdev setup --cli {path to azure-cli} --repo {path to azure-cli-extensions}6 Run aaz-dev-toolsaaz-devrun-c{pathtoazure-cli}-e{pathtoazure-cli-extensions}-s{pathswaggerorswagger-pr}-a{pathtoaaz}Before using generated commandsMake sure you have logined byaz login.Make sure you have switched to the subscription for test byaz account set -s {subscription ID for test}If your commands are in extensions, make sure you have loaded this extension byazdev extension add {your extension name}Other documentationsextensioncommand guidelinesauthoring testsshorthand syntax: Azure cli shorthand syntax can help cli users to pass complicated argument values. Only the arguments of AAZ(Atomic Azure CLI) commands generated by aaz-dev tool support shorthand syntax.Submit code and command modelsAfter finish the development, you should push the change in your forked repos first, and the create a Pull Request to upstream repos.azure-cli: create a Pull Request todevbranch ofAzure/azure-cliazure-cli-extensions: create a Pull Request tomainbranch ofAzure/azure-cli-extensionsaaz: create a Pull Request tomainbranch ofAzure/azzReporting issues and feedbackIf you encounter any bugs with the tool please file an issue in theIssuessection of our GitHub repository.LicenseMIT License
Copyright (c) Microsoft Corporation. All rights reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ""Software""), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
aaznutii-messenger-client | No description available on PyPI. |
aaznutii-messenger-server | No description available on PyPI. |
aa_zwb | UNKNOWN |
aazzxx | Failed to fetch description. HTTP Status Code: 404 |
ab | See usage here:https://github.com/dancrew32/ab/ |
ab12phylo | AB12PHYLOAB12PHYLOis an integrated, easy-to-use pipeline for Maximum Likelihood (ML) phylogenetic tree inference from ABI traces andFASTAdata.
At its core, AB12PHYLO runs parallelized instances ofRAxML-NG(Kozlov et al. 2019) orIQ-Tree(Nguyen et al. 2015) as well as a BLAST search in a reference database.
It enables visual, effortless sample identification based on phylogenetic position and sequence similarity, as well as population subset selection aided by metrics like Tajima's D for estimations of ongoing evolution, or definition of haplotypes.DocumentationThere are two versions of AB12PHYLO, both started from a terminal:ab12phyloas a graphical user interface intended to be more user-friendly and intuitive, and in some details more powerful thanab12phylo-cmd. This version, on the other hand, is a commandline-only tool for maximum reproducibility and automation of a linear pipeline.Whileab12phylocomes with its own on-screen help, and a very brief example forab12phylo-cmdis provided below, detailed installation and usage instructions can be found in thegithub wiki. Especially for the commandlineab12phylo-cmd, also check the in-line help viaab12phylo-cmd -h.For more individual support or feature requests, please write an email [email protected] can be installed using conda or pip:condainstall-clkndl-cconda-forge-cbiocondaab12phyloorpipinstallab12phylo:memo:WINDOWS USERSWindows usersmustuse Anaconda, and runab12phylo-initbefore starting the graphicalab12phylo!When AB12PHYLO is first run, it will check the system for three important non-python tools: RAxML-NG, IQ-Tree 2 and BLAST+. If they are not installed or outdated, AB12PHYLO can download the latest static binaries from GitHub or the NCBI respectively. Check thewikifor more details, troubleshooting, installing from source or updating the package.As implied above, start the graphical version viaab12phylofrom the terminal, and invoke the commandline version viaab12phylo-cmd.Quick start and functionalityABI trace files are the main input for AB12PHYLO. Additionally, wellsplate tables can be used to translate back to original sample IDs, provided the mapping is identical for all sequenced genes. Reference data may be included inFASTAformat, and the graphical AB12PHYLO acceptsFASTAsequences as the main input format as well.A:Sequence data is extracted from ABI trace files using a customisable quality control: Sequence ends are trimmed with a sliding window until a certain number (8 out of 10 by default) of bases reach the minimal accepted phred quality score (between 0 and 60, 30 by default). Bases with low phred quality are replaced byNonly if they form a consecutive stretch that is longer than a certain threshold (5 by default).B:Samples missing for a single locus are discarded for all genes. Trimmed traces as well as reference andFASTAsequences are aligned into single-gene Multiple Sequence Alignments (MSAs), which are then each trimmed to a user-defined level conserved positions using Gblocks 0.91b. For multi-gene analyses, the single-gene MSAs are then concatenated into a multi-gene MSA, which is used for ML tree inference. Trees are re-constructed using either RAxML-NG or IQ-Tree 2, with only the latter one available for Windows.C:AB12PHYLO allows editing of the resulting tree and selection of taxa by label matching, shared ancestry or manual picking. For these selected sub-populations, basic population genetics neutrality and diversity metrics are calculated from the conserved MSA positions only, with adjustable tolerance of gaps and unknown characters. The graphicalab12phylois both less cumbersome and more capable for these applications; the wiki pages (ab12phylo,ab12phylo-cmd) have more details.A BLAST search for species annotation can be run on a local database, or via the public NCBI BLAST API. However, importing XML results of aweb BLASTshould be preferred to running remote API calls as a main strategy.A simpleab12phylo-cmdexampleA simple real-world invocation of commandline AB12PHYLO might look like this:ab12phylo-cmd-abi<seq_dir>\-csv<wellsplates_dir>\-g<barcode_gene>\-rf<ref.fasta>\-bst1000\-dir<results>where:<seq_dir>contains all input ABI trace files, ending in.ab1<wellsplates_dir>contains the.csvmappings of user-defined IDs to sequencer's isolate coordinates<barcode_gene>was sequenced, seeherefor more info<ref.fasta>contains full GenBank reference recordslike this1000-bst=--bootstraptrees will be generated<results>is where results will beDependenciesBiopython,NumPy,pandas,Toytree<= 1.2.0,Toyplot,matplotlib,PyYAML,lxml,xmltramp2,svgutils,Pillow,Requests,Beautiful SoupandJinja2Non-python dependenciesThe pipeline will use existing installations of the programs listed below if they are found on the system$PATHand not considered outdated. Otherwise, bothab12phyloandab12phylo-cmdcan download the latest static binaries from GitHub or the NCBI on their initial runs or if run with--initialize.RAxML-NGversion >=1.0.2IQ-Tree 2BLAST+version >=2.9an MSA tool:MAFFT,Clustal Omega,MUSCLEorT-Coffee(clients for anEMBL serviceincluded)Gblocks0.91b for MSA trimming(included)ReferencesAlexey M. Kozlov, Diego Darriba, Tomáš Flouri, Benoit Morel, and Alexandros Stamatakis (2019)RAxML-NG: A fast, scalable, and user-friendly tool for maximum likelihood phylogenetic inference.Bioinformatics, btz305doi:10.1093/bioinformatics/btz305Nguyen,L. T., Schmidt,H. A., Von Haeseler,A., and Minh,B. Q. (2015)IQ-TREE: A fast and effective stochastic algorithm for estimating maximum-likelihood phylogenies.Molecular Biology and Evolution, 32, 268–274.doi:10.1093/molbev/msu300 |
ab1-organizer | ab1_organizerGoalOrganize AB1 files by researches and primer-pairs.InstalationFor command line usage, simpleously use pip way:pipinstallab1_organizerUsageab1_organizerreceive two arguments on initialization: the results file from Macrogen sequencing (-f, --file argument) and the modified order table (-t, --table argument). The sequencing file consists of the raw zipfile (file-name.zip) containing all .ab1, .pdf, phd.1, and .txt files. The order file consists of a simple excel table containing Macrogen order specifications and containing standardized headers (see next section).Standardized headersYour table would contain almost four columns, named respectively:sampleName: The unique identifier of sample;primerName: The primer name. e.g. "CO3 F", or "ITS1 R";personInCharge: The name of a person or a project responsible for the sample processing;primerCombination: Underscore separated complementary primer names. As example, if some region are sequenced using the "ITS1-F" and "ITS1-R", the primerCombination would be "ITS1-F_ITS1-R".At the terminal, run the code:ab1_organizer.py-f./path/to/zip/file-t./path/to/order/table.xlsxA new folder with the same name of the zip file will be created and all files will be organized by author and genomic marker respectively.Feel free to add new features and contribute through pull requests. Be happy!! |
ab2cb | No description available on PyPI. |
ab5 | UwUthere is vertical and horizontal gratients you can usevertical example:fromab5importvgratientlogo='''__ __ __ __/ / / / __/ / / // / / / | /| / / / / // /_/ /| |/ |/ / /_/ /\____/ |__/|__/\____/'''# color in decemal rgb [red,green,blue] (max 255 min 0)start_color=[0,223,50]end_color=[0,25,222]print(vgratient(logo,start_color,end_color))horizontal example:fromab5importhgratientlogo='''__ __ __ __/ / / / __/ / / // / / / | /| / / / / // /_/ /| |/ |/ / /_/ /\____/ |__/|__/\____/'''# color in decemal rgb [red,green,blue] (max 255 min 0)start_color=[0,223,50]end_color=[0,25,222]print(hgratient(logo,start_color,end_color)) |
aba | This is a tiny Python library for generating ABA/Cemtext/Direct Entry files
used by Australian banks for bulk payments.UsageSee example below.importdatetimefromaba.generatorimportAbaFilefromabaimportrecordsheader=records.DescriptiveRecord(user_bank='NAB',user_name='AJAX CRACKERS',user_number=12345,description='SALARIES',date=datetime.date(day=05,month=02,year=2000))entry=records.DetailRecord(bsb='123-456',account_number='123456',txn_code=53,amount=4242,payee_name='HACKER, J. RANDOM',lodgment_ref='RANDOM PAYMENT',sender_bsb='987-654',sender_account='445566777',remitter_name='AJAX CRACKERS',)aba_file=AbaFile(header)aba_file.add_record(entry)printaba_file.render_to_string() |
abaaba | Fusion is the next-generation AI + Big data runtime. |
abacat | Abacat (pronounced ‘ABBA-cat’) is a toolkit for working with bacterial whole genome sequencing (WGS) data. It provides Python objects to represent elements which are common to WGS analysis workflows, such as coding sequence (CDS) files, containing genes or proteins, alignment methods, or statistics about your sequences. |
abacba | No description available on PyPI. |
abaculate | No description available on PyPI. |
abacus | Helper library for Tornado web framework |
abacusai | No description available on PyPI. |
abacusevents | abacusevents======Some common Python tools for sending events across Abacus services |
abacus-icalc | AbacusPowerful interactive calculatormade in Python using Python with Python supportInstallationTo install Abacus run the following command with pip installedpython-mpipinstallabacus-icalc[ipython]LatestAnother option is to install the latest version from master branchpython-mpipinstallabacus-icalc[ipython]@https://github.com/sandorex/abacus.gitFor other branches append@branchto the url like sopython-mpipinstallabacus-icalc[ipython]@git+https://github.com/sandorex/abacus.git@branchIPython or notIPython is currently recommended way of using Abacus as it has all the features, i am planning making many features available without it too but it requires a lot of effort and time so it will have to waitProject goalsThe project is meant to be an interactive algebra calculator with scripting supportThere are plenty of things i wanted to add (or may add in the future) like:Unit support / conversion, this is kinda supported using sympy units but is not very intuitive and easy to useGUI, this is planned but i am putting it off as its not a priorityPython supportPython is considered first class citizen and should always be supported in Abacus, if you encounter python code that doesn't run cause of syntax errors that is a bug and please report itAlternativesTODO |
abacus-py | abacusA minimal yet valid double-entry accounting system in Python.DocumentationSee project documentation athttps://epogrebnyak.github.io/abacus/.Installationpip install abacus-pyFor latest version install from github:pip install git+https://github.com/epogrebnyak/abacus.gitabacus-pyrequires Python 3.10 or higher.Quick exampleLet's do Sample Transaction #1 fromaccountingcoach.com[^1].[^1]: It is a great learning resource for accounting, highly recommended.On December 1, 2022 Joe starts his business Direct Delivery, Inc. The first transaction that Joe will record for his company is his personal investment of $20,000 in exchange for 5,000 shares of Direct Delivery's common stock.
Direct Delivery's accounting system will show an increase in its account Cash from zero to $20,000, and an increase in its stockholders' equity account Common Stock by $20,000.SolutionBoth Python code and command line script below will produce balance sheet after Sample Transaction #1 is completed.Python code:fromabacusimportChart,Reportchart=Chart(assets=["cash"],capital=["common_stock"])ledger=chart.ledger()ledger.post(debit="cash",credit="common_stock",amount=20000,title="Owner's investment")report=Report(chart,ledger)print(report.balance_sheet)Command line script:bxinit
bxpost--entryasset:cashcapital:common_stock20000--title"Initial investment"bxreport--balance-sheetResultBalance sheet
ASSETS 20000 CAPITAL 20000
Cash 20000 Common stock 20000
Retained earnings 0
LIABILITIES 0
TOTAL 20000 TOTAL 20000See further transactions for this example atdocumentation website. |
abacusSoftware | AbacusSoftwareAbacus Software is a suite of tools built to ensure your experience with Tausand's coincidence counters becomes simplified.Written in Python3, abacusSoftware relies on the following modules:pyAbacuspyqtgraphNumPyPyQt5pyserialqtmodernPreviewA quick demo video to preview this software is available at:https://youtu.be/c4QO8p1WeSEInstallationabacusSoftwarecan be installed usingpipas:pip install abacusSoftwareOr from GitHubpip install git+https://github.com/Tausand-dev/abacusSoftware.gitExecute abacusSoftwareOn a terminal or command prompt typeabacusSoftwareGrant port access on LinuxMost Linux configurations have a dialout group for full and direct access to serial ports. By adding your user account to this group you will have the necessary permissions for Abacus Software to communicate with the serial ports.Open Terminal.Enter the following command, replacing<username>with the name of your account.sudo usermod -a -G dialout <username>Sign in and out for the changes to take effect.For developersCreating a virtual environmentRun the following code to create a virtual environment called.venvpython -m venv .venvActivateOn Unix systems:source .venv/bin/activateOn Windows:.venv\Scripts\activateDeactivatedeactivateInstalling packagesAfter the virtual environment has been activated, install required packages by using:python -m pip install -r requirements.txtFreezing codeAfter activating the virtual environmentWindowsRun the following commandpyinstaller --additional-hooks-dir installers/pyinstaller_hooks/ --name AbacusSoftware --onefile --noconsole -i abacusSoftware/GUI/images/abacus_small.ico test.pyTwo folders will be created: build and dist. Insidedistyou'll find the.exefile. To create an installer, first install Inno Setup fromhttps://jrsoftware.org/isinfo.php#stable. Then, using the File Explorer, go to the folderinstallersand double-clickinstaller_builder.issor open it from Inno Setup if it is already opened. Click on the play icon and then follow the process, which includes the creation of the installer and the installation itself.The installer will be saved in a folder calledOutput.MacOSRun the following commandpyinstaller --additional-hooks-dir installers/pyinstaller_hooks/ --name AbacusSoftware --onefile --noconsole -i abacusSoftware/GUI/images/Abacus_small.png test.pyTwo folders will be created: build and dist. Insidedistyou'll find the.appfile. This file can be run from a console by executing the command
To change the icon of the.appfile follow the instructions herehttps://appleinsider.com/articles/21/01/06/how-to-change-app-icons-on-macosLinuxRun the following commandpyinstaller --additional-hooks-dir installers/pyinstaller_hooks/ --name AbacusSoftware --onefile --noconsole -i abacusSoftware/GUI/images/Abacus_small.png test.pyTwo folders will be created: build and dist. Inside dist you'll find the executable file. This file can be run from a console by executing the command./AbacusSoftwareIf it doesn't run, make sure it has execute permissions. In case it doesn't runchmod +x AbacusSoftwareand then try again. The executable file could be used to create a Desktop entry so it can be lauched as an application (for example in Gnome, an icon could be assigned)To create an AppImage that can be run from multiple Linux distributions and be launch by double clicking, follow the next steps.Create the following folder path:
AbacusSoftware.AppDir/usr/binPlace the executable inside the bin folderPlace the icon Abacus_small.png located at abacusSoftware/GUI/images/Abacus_small.png inside AbacusSoftware.AppDirCreate a file called AbacusSoftware.desktop inside AbacusSoftware.AppDirEdit the.desktopfile with the following[Desktop Entry]
Name=AbacusSoftware
Exec=AbacusSoftware
Icon=Abacus_small
Type=Application
Categories=Utility;Give execution permisions to the.desktopfile:chmod +x AbacusSoftware.desktopCreate a script calledAppRunwith the following contents#!/bin/bash
SELF=$(readlink -f "$0")
HERE=${SELF%/*}
EXEC="${HERE}/usr/bin/AbacusSoftware"
exec "${EXEC}"Give execution permisions to theAppRunfile:chmod +x AppRun. After this step, the app should run after doing./AppRunon a Terminal.For 64-bit architecture, download appimagetool-x86_64.AppImage fromhttps://github.com/AppImage/AppImageKit/releases/and give execution permisions to it.Place appimagetool outside AbacusSoftware.AppDir and runARCH=x86_64 ./appimagetool-x86_64.AppImage AbacusSoftware.AppDirThe fileAbacusSoftware-x86_64.AppImagewill be created. This file can be opened by double clicking it.Generating images and iconsIn linux,cdintoabacusSoftware/GUI/images/, where you'll find the image files that will be used in the application. You'll also find a .qrc file which specifies any image that you want to include. If you want to use new images you'll need to specify their name inside such file. Next execute the following commandpyrcc5 -o __GUI_images__.py images.qrcThis will update the__GUI_images__.pyfile, which needs to be copied into the folderabacusSoftwareand replace the file located there with the same name. Now the image resources can be called from within the code by doing, for example,splash_pix = QtGui.QPixmap(':/splash.png').scaledToWidth(600)Fixing pyinstaller:https://github.com/pyinstaller/pyinstaller/commit/082078e30aff8f5b8f9a547191066d8b0f1dbb7ehttps://github.com/pyinstaller/pyinstaller/commit/59a233013cf6cdc46a67f0d98a995ca65ba7613a |
abacus-tpot | Analysis LibraryInstallationCreate a Python virtual environment then run:pipinstallabacus-tpotDevelopmentThis project has a.editorconfigfile to help contributors define
and maintain consistent coding styles between different editors and
IDEs.We are using CircleCI for continuous integration.Found a bug or want to propose something to the team? Create a new issue
if it is not listedhere. Even better, feel free to fork this repo,
make the changes and raise a PR. We’ll be more than happy to review it.TestingRun:pythonsetup.pytestDeploymentAutomatic Uploading totestpypiandpypihas been set in the CI
and only develop and master branches are deployed to the package
repositories respectively.Ready to deploy? Update the version insetup.pyand create a new git
tag withgit tag $VERSION. Push the tag to GitHub withgit push--tags, a new CircleCI build is triggered and will only
confirm that the package is ready for uploading. The upload will only
happen whenmasterordevelopare pushed and successfully build.DocsGoing throughthis jupyter notebookwill give you a sense of what the
abacus packs in. |
abacusutils | abacusutilsabacusutils is a package for reading and manipulating data products from the AbacusN-body project.
In particular, these utilities are intended for use with theAbacusSummitsuite of simulations. The package focuses on the Python 3 API, but there is also a language-agnostic Unix pipe
interface to some of the functionality.These interfaces are documented here:https://abacusutils.readthedocs.ioPress the GitHub "Watch" button in the top right and select "Custom->Releases" to be notified about bug fixes
and new features!InstallationThe Python abacusutils package is hosted on PyPI and can be installed
by installing "abacusutils":pip install abacusutilsorpip install abacusutils[all]For more information, seehttps://abacusutils.readthedocs.io/en/latest/installation.html.Usageabacusutils has multiple interfaces, summarized here and athttps://abacusutils.readthedocs.io/en/latest/usage.html.Specific examples of how to use abacusutils to work with AbacusSummit data will soon
be given at the AbacusSummit website:https://abacussummit.readthedocs.ioPythonThe abacusutils PyPI package contains a Python package calledabacusnbody.
This is the name to import (notabacusutils, which is just the name of the PyPI package).
For example, to import thecompaso_halo_catalogmodule, useimportabacusnbody.data.compaso_halo_catalogUnix PipesThepipe_asdfPython script reads columns from ASDF files and pipes them tostdout. For example:$pipe_asdfhalo_info_000.asdf-fN-fx_com|./client |
ab-addnm | No description available on PyPI. |
abadge | Generate status badges/shields of pure HTML+CSS.OverviewTheBadgeclass in the module is used to generate status badges. It
supports various configuration options like font, background etc., and also
includes threshold support, which is useful for presenting job status, for
example.UsageBadgecan be instantiated to generate many badges with the same format:from abadge import Badge
success_badge = Badge(value_text_color='#11a')
print(success_badge.to_html('build', 'passed'))
print(success_badge.to_html('tests', 'ok'))or for one-shot generation:print(Badge(label='tests', value='4/8').to_html())
print(Badge().to_html(label='tests', value='4/8')) # Same thing
print(Badge.make_badge(tests, '4/8')) # This tooThe arguments to all of the methods are identical. The arguments to the
constructor will be stored in the instance as default values which can then
be overridden by the arguments to theto_htmlmethod.make_badgealways
use the class default configuration (it is a class method).ArgumentsAll three methods support the following arguments:Optional argumentslabel:text for the label (left) part. Can also be given as keyword argumentlabel=<text>value:text for the value (right) part. Can also be given as keyword argumentvalue=<text>Keyword argumentsborder_radius:how rounded the corners of the badge should be (CSS “padding”)font_family:font to use in the badge (CSS “font-family”)font_size:font size to use in the badge (CSS “font-size”)label:the text in label part of the badgelabel_background:background color for the label (left) part (CSS “background”)label_text_color:text color for the label (left) part (CSS “color”)label_text_shadow:configuration for the text shadow (CSS “text-shadow”)link_decoration:decoration for the link (CSS “text-decoration”)padding:amount of space between the border and the text (CSS “padding”)thresholds:dict withlabel-specific configuration options, so that multiple labels
can be handled by the same class instance. SeeThresholdsbelowurl:makes the badge link to the given URLvalue:the text in the value part of the badgevalue_background:background color for the value part (CSS “background”). This is also
the final fallback if the value is neither found inthresholdsnor invalue_backgroundsvalue_backgrounds:dict withvaluetovalue_backgroundmappings. SeeThresholdsbelowvalue_text_color:text color for the value part (CSS “color”)value_text_shadow:configuration for the text shadow (CSS “text-shadow”)ThresholdsThethresholdsargument is a dict with label as key and a configuration
dict as value. The dict supports the following keys:order:May be:auto,float,int,str, orstrict, withautobeing the default iforderdoes not exist.float,intandstrforces level of that type (see below).autouses ordering of
typefloatorintif allvaluesincolorsare numbers type, withfloattaking precedence. Ifautois set and at least one value is a
string, or ifstrictis set, then an exact match is used for
determining color, ie. no orderingcolors:dict withvaluetocolormappingabove:Value is a color. if an ordering is requested, and the given value is above
the highest value (key) incolors, then this color is usedshade:Whether to shade the color depending on distance between the thresholds.
Each R, G, and B color is calculated based on the fraction of the distance
of the value between the thresholdsLevels are handled by sorting the keys in thecolorsdict and comparing
the incoming value to each of the keys, starting with the key with the lowest
value, until the value is lower than or equal to the key:for k in sorted(thresholds['colors'].keys, key=<sort by type>):
if value <= k:
return thresholds['colors'][k]
return thresholds['above']ExamplesOne instance can be configure to product different label types:build_badge = Badge(thresholds={
'build': {
'colors': {'SUCCESS': '#0f0',
'FAILURE': '#f00',
'UNSTABLE': '#ff0',
'ABORTED': '#f80', }},
'KPI': {
'order': 'str',
'colors': {'A': '#0f4',
'B': '#f04',
'C': '#f84',
'D': '#ff4', }},
'passrate': {
'colors': {0.3: '#f00',
0.6: '#c40',
0.8: '#4c0', },
'above': '#0f0', }})
print(build_badge.to_html('build', 'UNSTABLE'))
# Using a non-existing value will use the value_background color
print(build_badge.to_html('build', 'SKIP'))
print(build_badge.to_html('build', 'HOP', value_background='#ccc'))
print(build_badge.to_html('passrate', 0.5))If the color is not found inthresholdsthen the value will be looked
up in thevalue_backgroundsdict as a fallback:build_badge = Badge(thresholds={
'build': {
'colors': {'SUCCESS': '#0f0',
'FAILURE': '#f00',
'UNSTABLE': '#ff0',
'ABORTED': '#f80', }},
'value_backgrounds': {'SUCCESS': '#0f4',
'FAILURE': '#f04',
'UNSTABLE': '#f84',
'ABORTED': '#ff4'}})
print(build_badge.to_html('test', 'ABORTED'))Shading does not produce color steps, but a shade between the colors in the
threshold. Shading only works for “float” and “int” types:build_badge = Badge(thresholds={
'speed': {
'shade': True,
'colors': {0: '#0f0',
120: '#f00'}, # speed limit
'above': '#f08'}} # too fast!
)
print(build_badge.to_html('speed', 97))
# Here is the rainbow
build_badge = Badge(thresholds={
'rainbow': {
'shade': True,
'colors': {0.0: '#ff0000',
1.0: '#ffff00',
2.0: '#00ff00',
3.0: '#00ffff',
4.0: '#0000ff',
5.0: '#8000ff'}}})
for c in range(0, 11):
print(build_badge.to_html('rainbow', c / 2.0)) |
abadon-sdk | Abadon SDK |
abagen | This package provides a Python interface for fetching and working with theAllen Human Brain Atlas(AHBA) microarray expression data.OverviewIn 2013, the Allen Institute for Brain Science released theAllen Human Brain
Atlas, a dataset containing microarray expression data collected from six
human brains (Hawrylycz et al., 2012) . This dataset has offered an
unprecedented opportunity to examine the genetic underpinnings of the human
brain, and has already yielded novel insight into e.g.,adolescent brain
developmentandfunctional
brain organization.However, in order to be effectively used in most analyses, the AHBA microarray
expression data often needs to be (1) collapsed into regions of interest (e.g.,
parcels or networks), and (2) combined across donors. While this may
potentially seem trivial, there are a number of analytic choices in these steps
that can dramatically influence the resulting data and any downstream analyses.
Arnatkevičiūte et al., 2019 provided a thorough treatment of this in arecent
manuscript, demonstrating how the techniques and code used to
prepare the raw AHBA data have varied widely across published reports.The current Python package,abagen, aims to provide reproducible workflows
for processing and preparing the AHBA microarray expression data for analysis.Installation requirementsCurrently,abagenworks with Python 3.6+ and requires a few dependencies:nibabelnumpy (>=1.14.0)pandas (>=0.25.0), andscipyThere are some additional (optional) dependencies you can install to speed up
some functions:fastparquet, andpython-snappyThese latter packages are primarily used to facilitate loading the (rather
large!) microarray expression dataframes provided by the Allen Institute,For detailed information on how to installabagen, including these
dependencies, refer to ourinstallation instructions.QuickstartAt it’s core, usingabagenis as simple as:>>>importabagen>>>expression=abagen.get_expression_data('myatlas.nii.gz')where'myatlas.nii.gz'points to a brain parcellation file.This function can also be called from the command line with:$abagen--output-fileexpression.csvmyatlas.nii.gzFor more detailed instructions on how to useabagenplease refer to ouruser guide!Development and getting involvedIf you’ve found a bug, are experiencing a problem, or have a question about
using the package, please head on over to ourGitHub issuesand make a new
issue with some information about it! Someone will try and get back to you
as quickly as possible, though please note that the primary developer forabagen(@rmarkello) is a graduate student so responses make take some time!If you’re interested in getting involved in the project: welcome ✨!
We’re thrilled to welcome new contributors. You should start by reading ourcode of conduct; all activity onabagenshould adhere to the CoC. After
that, take a look at ourcontributing guidelinesso you’re familiar with the
processes we (generally) try to follow when making changes to the repository!
Once you’re ready to jump in head on over to our issues to see if there’s
anything you might like to work on.CitingabagenFor up-to-date instructions on how to cite abagen please refer to ourdocumentation.License InformationThis codebase is licensed under the3-clause BSD license. The full license
can be found in theLICENSEfile in theabagendistribution.Reannotated gene information located atabagen/data/reannotated.csv.gzand
individualized donor parcellations for the Desikan-Killiany atlas located atabagen/data/native_dkare taken from Arnatkevičiūte et al., 2018 and are
separately licensed under theCC BY 4.0; these data can also be found onfigshare.Corrected MNI coordinates used to match AHBA tissues samples to MNI space
located atabagen/data/corrected_mni_coordinates.csvare taken from thealleninf package, provided under the3-clause BSD license.All microarray expression data is copyrighted undernon-commercial reuse
policiesby the Allen Institute for Brain Science (© 2010 Allen Institute for
Brain Science. Allen Human Brain Atlas. Available from:Allen Human Brain
Atlas).All trademarks referenced herein are property of their respective holders. |
abageotests | abageotestsA package to generate and execute python scripts of abaqus models of geotechnical tests.DependenciesIn order to use this package, you need to install thenumpyandmatplotlibpackage:pipinstallnumpy
pipinstallmatplotlibAnd furthermore, install abaqus properly, and link the FORTRAN compiler to abaqus, and add the abaqus commands directory to the system path environment.And then install this package:pipinstallabageotestsYou can also find this project inHailin-Wang/abageotests: A package to generate and execute python scripts of abaqus models of geotechnical tests. (github.com).ExamplesAn example of direct shear testfromabageotestsimport*dst=AbaqusDirectShearTest(AbaqusCalculationMethod.Standard)dst.InitialStressGeneralStaticStep(time_period=1.0,initial_increment_size=0.1,maximal_increment_size=1.0,maximal_increments=10000)dst.ShearGeneralStaticStep(time_period=1.0,initial_increment_size=0.01,maximal_increment_size=0.01,maximal_increments=1000000)dst.Displacement(0.006,0,0,0,0,0)dst.NormalContact(AbaqusNormalContactType.Hard,constraintEnforcementMethod=DEFAULT)dst.TangentialContact(AbaqusTangentialContactType.Frictionless)dst.WorkDirectory('dst-example')dst.SoilGeometry(0.06,0.06,0.02)dst.SolidGeometry(0.1,0.1,0.02)dst.SoilMesh(AbaqusMeshMethod.BySize,0.01)dst.SolidMesh(AbaqusMeshMethod.BySize,0.01)dst.SoilMaterial(4e4,0.0,2e8)dst.SolidMaterial(2e8,0.0,2.0)dst.FieldOutput(['S','E','LE','U','RF','RT','RM','P','CSTRESS','CDISP','CFORCE','CNAREA','CSTATUS'])dst.HistoryOutput(['U1','RF1'],50)dst.Pressure(310)dst.PredefinedStress(-310,-310,-310,0,0,0)dst.ModelName('dst')dst.OutputName('output')dst.generateAbaqusPythonScript()dst.generateAbaqusCaeModel()dst.submit()dst.extractOutputData()dst.plot()dst.resetWorkDirectory()An example of pullout testfromabageotestsimport*pullout=AbaqusPullOut(AbaqusCalculationMethod.Standard)pullout.NailGeometry(0.05,1.2)pullout.SoilGeometry(1.0,0.3,0.8)pullout.NailOffsetGeometry(0.4)pullout.SoilMaterial(4e4,0.3,None,30.0,3.0,5.0,0.0)pullout.NailMaterial(3.2e7,0.2)pullout.Displacement(0.0,0.0,8e-4,0.0,0.0,0.0)pullout.Pressure(310.0)pullout.PredefinedStress(-310.0,-310.0,-310.0,0.0,0.0,0.0)pullout.NormalContact(AbaqusNormalContactType.Hard,constraintEnforcementMethod=DEFAULT)pullout.TangentialContact(AbaqusTangentialContactType.Frictionless)pullout.SoilMesh(AbaqusMeshDenseMethod.General,AbaqusMeshMethod.BySize,0.025)pullout.SoilMesh(AbaqusMeshDenseMethod.Dense,AbaqusMeshMethod.BySize,0.01)pullout.NailMesh(AbaqusMeshDenseMethod.General,AbaqusMeshMethod.BySize,0.025)pullout.NailMesh(AbaqusMeshDenseMethod.Dense,AbaqusMeshMethod.BySize,0.01)pullout.InitialStressGeneralStaticStep(time_period=1.0,initial_increment_size=0.01,maximal_increment_size=0.1,minimal_increment_size=0.001,maximal_increments=1000)pullout.PulloutGeneralStaticStep(time_period=1.0,initial_increment_size=0.01,maximal_increment_size=0.1,minimal_increment_size=0.001,maximal_increments=1000)pullout.FieldOutput(['S','E','LE','U','V','A','RF','P','CSTRESS','CFORCE','FSLIPR','FSLIP','PPRESS'])pullout.HistoryOutput(['U1','RF1'],50)pullout.WorkDirectory('pullout-example')pullout.ModelName('pullout')pullout.OutputName('output')pullout.generateAbaqusPythonScript()pullout.generateAbaqusCaeModel()pullout.submit()pullout.extractOutputData()pullout.resetWorkDirectory() |
abagnale | abagnaleGenerate fake traffic to websites. |
abakaffe-cli | UNKNOWN |
abakus-status-checks | Abakus Status Checks====================.. image:: https://ci.frigg.io/eirsyl/abakus-status-checks.svg:target: https://ci.frigg.io/eirsyl/abakus-status-checks/last/:alt: Build Status.. image:: https://ci.frigg.io/eirsyl/abakus-status-checks/coverage.svg:target: https://ci.frigg.io/eirsyl/abakus-status-checks/last/:alt: Coverage StatusThis package is used together with Sensu_. Checks is managed with Puppet and reported to our #devopschannel on Slack.Supported checks:- CPU percent- LoadCreate a new check------------------- Create a new file in the abakus_checks/checks directory- Import abakus_checks.utils.check.StatusCheck and use this as a base for your check.- Give the check a name, decription and options::name = 'load'description = 'Trigger errors based on load threshold. Load is divided by core count.'options = [click.option('--warning', default='2,1.5,1', type=str),click.option('--critical', default='3,2,1.5', type=str),]- Implement the run method. Call self.ok, self.warning, self.critical with a message based on theresult.- Register the check in abakus_checks/cli.py. Import the check in the check import block andregister the check.::from .checks import loadregister_check(load.LoadCheck)- You can use the tests.test_case.CLITestCase to test the check. This TestCase has a .invokemethod you can use to call the check.::class LoadCheckTestCase(CLITestCase):@mock.patch('os.getloadavg', return_value=(0, 0, 0))def test_load_ok(self, mock_loadavg):result = self.invoke(['load', '--warning /'3.2.1/''])self.assertEquals(result.exit_code, 0).. _Sensu: https://sensuapp.org/ |
abalin-nameday | abalin_namedaySimple Python wrapper for the International NameDay API @https://api.abalin.netInstallationUse the package managerpipto installabalin_nameday.pipinstallabalin_namedayUsageimportabalin_namedaymyClient=abalin_nameday.namedayRequestor(country,timezone)print(json.dumps(json.loads(myClient.GetData()),indent=2,sort_keys=True))Explanationcountry: one of the countries from this list:['cz','sk','pl','fr','hu','hr','se','us','at','it','es','de','dk','fi','bg','lt','ee','lv','gr','ru']timezone: One of the time zones from this list:'America/Denver','America/Costa_Rica','America/Los_Angeles','America/St_Vincent','America/Toronto','Europe/Amsterdam','Europe/Monaco','Europe/Prague','Europe/Isle_of_Man','Africa/Cairo','Africa/Johannesburg','Africa/Nairobi','Asia/Yakutsk','Asia/Hong_Kong','Asia/Taipei','Pacific/Midway','Pacific/Honolulu','Etc/GMT-6','US/Samoa','Zulu','US/Hawaii','Israel','Etc/GMT-2',If the call is successful,abalin_namedayreturns a string that contains today's date and name day in the selected country. It also contains version information about itself.See thedocumentation of the actual APIfor up to date list of countries/time zones supported.Sample response fromowm2json:{"module":{"version":"0.0.1"},"namedays":{"data":{"dates":{"day":5,"month":4},"namedays":{"hu":"Vince"}}}}ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseGNU General Public License v3.0 |
abalone | UNKNOWN |
abalone-boai | Abalone BoAIThis is a Python implementation of the board gameAbalone.It is primarily intended to be played by artificial intelligence, but also offers the option to play as a human player.Command Line UsageA minimal command line interface for running a game is provided byabalone/run_game.py. From theabalonedirectory run:$ ./run_game.py <black player> <white player>Replace<black player>and<white player>each with an artificial intelligence (or human player if you want to play yourself).For instance, play against an AI that makes random moves:$ ./run_game.py human_player.HumanPlayer random_player.RandomPlayerLoading your own AI works analogously with<module>.<class>.Abalone RulesFromWikipedia(CC BY-SA):Abalone is an award-winning two-player abstract strategy board game designed by Michel Lalet and Laurent Lévi in 1987. Players are represented by opposing black and white marbles on a hexagonal board with the objective of pushing six of the opponent's marbles off the edge of the board.The board consists of 61 circular spaces arranged in a hexagon, five on a side. Each player has 14 marbles that rest in the spaces and are initially arranged as shown below, on the left image. The players take turns with the black marbles moving first. For each move, a player moves a straight line of one, two or three marbles of one color one space in one of six directions. The move can be either broadside / arrow-like (parallel to the line of marbles) or in-line / in a line (serial in respect to the line of marbles), as illustrated below.Initial positionBlack opens with a broadside moveWhite counters with an in-line moveA player can push their opponent's marbles (a "sumito") that are in a line to their own with an in-line move only. They can only push if the pushing line has more marbles than the pushed line (three can push one or two; two can push one). Marbles must be pushed to an empty space (i.e. not blocked by a marble) or off the board. The winner is the first player to push six of the opponent's marbles off of the edge of the board.Write Your Own Artificial IntelligenceIn order to write your own AI, create a python file with a class that inherits fromabstract_player.AbstractPlayerand implement theturnmethod:fromabstract_playerimportAbstractPlayerclassMyPlayer(AbstractPlayer):defturn(self,game,moves_history):pass# TODO: implementHave a look atrandom_player.pyfor a sample implementation.Refer to thedocumentationfor details about the parameters and the return type.A particularly useful method isgame.generate_legal_moves(). It yields all legal moves that the AI can perform. Theturnmethod can simply return one of the yielded values.A "move"The return value of theturnmethod is called amove. This is a tuple, which consists firstly of the marbles to be moved and secondly of the direction of movement.The marbles are specified by the space where they are located on the board (see the image at the beginning of this document for the notation of the spaces). All spaces are listed in theSpaceenum. For an inline move only the trailing marble ("caboose") of the line to be moved is specified. For a broadside move only the two outermost marbles are given in a tuple.The second element of the tuple is the direction of movement. These are all listed in theDirectionenum.
Therefore the two example moves from the images above (seeAbalone Rules) would look like this:fromenumsimportDirection,Space# Black opens with a broadside move# (returned from the turn method of the black player)return(Space.C3,Space.C5),Direction.NORTH_WEST# White counters with an in-line move# (returned from the turn method of the white player)returnSpace.I8,Direction.SOUTH_WESTContributeAll contributions are welcome. SeeCONTRIBUTING.mdfor details.See AlsoAbalone Rulebook (PDF) |
abalytics | ABalytics: Advanced A/B Testing Statistical AnalyticsABalytics is a Python package designed for statistical analysis, particularly for assessing the significance of A/B testing results. Its goal is to provide high-quality analysis by selecting the appropriate statistical tests based on the type of variable being analyzed. It offers a suite of tools to perform various significance tests and posthoc analyses on experimental data.FeaturesBoolean and Numeric Analysis: Supports analysis of both boolean and numeric data types, ensuring the use of correct statistical methods for each.Significance Tests: Includes a variety of significance tests such as Chi-Square, Welch's ANOVA, and Kruskal-Wallis, to accurately determine the significance of results.Posthoc Analysis: Offers posthoc analysis methods like Tukey's HSD, Dunn's test, and Games-Howell, for detailed examination following significance tests.Normality and Homogeneity Checks: Performs checks for Gaussian distribution and homogeneity of variances using Levene's test, which are critical for selecting the right tests.Data Transformation: Provides functionality to convert data from long to wide format, facilitating analysis of dependent groups.Pretty Text Output: Generates a formatted text output with the results of the statistical tests, facilitating interpretation and reporting.InstallationTo install ABalytics, use pip:pipinstallabalyticsUsageAnalyzing ResultsABalytics provides two main functions for analyzing A/B testing results:analyze_independent_groupsandanalyze_dependent_groups.Independent Groups Analysisanalyze_independent_groupsis used for analyzing data where the groups are independent of each other. It takes a pandas DataFrame, the name of the column containing the variable to analyze, the name of the column containing the grouping variable, and optional parameters for p-value threshold and minimum sample size.Example:fromabalyticsimportanalyze_independent_groupsimportpandasaspd# Load your data into a pandas DataFramedf=pd.read_csv('your_data.csv')# Analyze the resultsanalysis_results=analyze_independent_groups(df,variable_to_analyze="order_value",group_column="ab_test_group",)Dependent Groups Analysisanalyze_dependent_groupsis used for analyzing data where the groups are dependent, such as repeated measures on the same subjects. It requires data in wide format. If your data is in long format, you can use theconvert_long_to_widefunction inabalytics.utilsto convert it. Theanalyze_dependent_groupsfunction takes a pandas DataFrame, the names of the columns to compare, and optional parameters for p-value threshold and minimum sample size.Example:fromabalyticsimportanalyze_dependent_groupsimportpandasaspd# Load your data into a pandas DataFramedf=pd.read_csv('your_data.csv')# Analyze the resultsanalysis_results=analyze_dependent_groups(df,variables_to_compare=["pre_test_score","post_test_score"],)Data TransformationTheconvert_long_to_widefunction inabalytics.utilsis designed to transform data from long format to wide format, with an option to keep multi-level columns or flatten them.analyze_dependent_groupsrequires data in wide format to operate correctly.Example:fromabalytics.utilsimportconvert_long_to_wideimportpandasaspd# Assuming 'df_long' is your pandas DataFrame in long formatdf_wide=convert_long_to_wide(df_long,index_col="subject_id",columns_col="condition",flatten_columns=True# Set to False if you wish to keep multi-level columns)Generating Pretty Text OutputTo get a formatted text output of your results, you can use theutils.format_results_as_tablefunction.Example:fromabalytics.utilsimportformat_results_as_tablefromabalyticsimportanalyze_independent_groupsimportpandasaspd# Load your data into a pandas DataFramedf=pd.read_csv('your_data.csv')# Analyze the resultsanalysis_results=analyze_independent_groups(df,variable_to_analyze="order_value",group_column="ab_test_group",)# Generate pretty text outputpretty_text=format_results_as_table(abalytics_results=[analysis_results],identifiers_list=[{"Test name":"A/B Test 1","Channel":"Mobile"}],)print(pretty_text)Executing this code will output a neatly formatted table displaying the outcomes of the statistical significance tests. The table includes the sample size and the test results. Optionally, you can setshow_detailstoTrueto include additional details such as the a priori and posthoc tests used. By default, only the significant results are displayed. This can be changed by settingshow_only_significant_resultstoFalse.Example output:Test name Channel n Result p-value
-------------------- ---------- ----- ------------------------------------------------ ---------
A/B Test 1 Mobile 5009 new_cta_1 (0.16) > new_cta_2 (0.15) 0.007
A/B Test 1 Tablet 2887 new_cta_1 (0.22) > new_cta_2 (0.20) 0.000
A/B Test 1 Tablet 2887 new_cta_1 (0.22) > old_implementation (0.20) 0.005
A/B Test 1 Desktop 20014 new_cta_1 (0.18) > new_cta_2 (0.17) 0.000
A/B Test 1 Desktop 20014 new_cta_1 (0.18) > old_implementation (0.17) 0.000
A/B Test 2 Mobile 268 new_cta_1 (0.10) > new_cta_2 (0.06) 0.006
A/B Test 2 Mobile 268 new_cta_1 (0.10) > old_implementation (0.06) 0.014
A/B Test 2 Desktop 5609 new_cta_1 (0.13) > new_cta_2 (0.12) 0.025Further examples of how to use ABalytics can be found inexamples/example.py.ContributingContributions to ABalytics are welcome. If you have suggestions for improvements or find any issues, please open an issue or submit a pull request. |
abalyzer | abalyzerParses ABA (American Bankers Association) codesAbout The ProjectParsing out information from ABA numbers can be tricky without the use of online lookup tools. This project aims to create an offline and open-source alternative. When used, the package can be used to validate ABA numbers and if valid, return information about the number including:Bank NameBank AddressBank StateBank Phone NumberABA Number Validation:Check digitThe ninth, check digit provides a checksum test using a position-weighted sum of each of the digits. High-speed check-sorting equipment will typically verify the checksum and if it fails, route the item to a reject pocket for manual examination, repair, and re-sorting. Mis-routings to an incorrect bank are thus greatly reduced.The following condition must hold:(3(d1 + d4 + d7) + 7(d2 + d5 + d8) + (d3 + d6 + d9)) mod 10 = 0(back to top)LicenseDistributed under the MIT License. SeeLICENSE.txtfor more information.(back to top) |
abandoned-butterfly | abandoned_butterflyassignment 2title goes here
how to rune |
abandoned-tron | No description available on PyPI. |
abandontech-siren | McRconPython package for authenticating and communicating with a Minecraft server using the Minecraft RCON protocolSample UsageimportasynciofromsirenimportRconClientasyncdeftest_auth()->None:asyncwithRconClient("123.2.3.4",25575,"AVeryRealPassword")asclient:print(awaitclient.send("list"))if__name__=='__main__':loop=asyncio.new_event_loop()loop.run_until_complete(test_auth()) |
abante | No description available on PyPI. |
abanteai | No description available on PyPI. |
abao-matrix-operations | No description available on PyPI. |
abaparser | # ABA Parser/Reporter in Python #ABA (Australian Bankers Association or Cemtext file format) is the standard format all Australian online banks accept. This is an archaic fixed file format, and it’s hard to eye-ball for correctness.This script serves currently serves 2 purposesA python library to parse ABA files.A basic command line report of all the debit transactions in the ABA file (I use this to sanity check payments out of Xero)## Usage ##
`
$ python abaparser.py < path/to/FILE.ABA
`The output will be something like this` Contractors012-327293353749 John Doe Contractor Payment 1220.00082-406598209320 Jane Doe Contractor Payment 6600.00 ` |
ab-api | This is a security placeholder package.
If you want to claim this name for legitimate purposes,
please contact us [email protected]@yandex-team.ru |
abaqus2dyna | No description available on PyPI. |
abaqus-mtx-parser | Parser for*.mtxfiles inAbaqusA python package to parse*.mtxfiles generated by the keyword*SUBSTRUCTURE MATRIX OUTPUTin Abaqus.InstallUse PyPI to installabaqus-mtx-parser:pipinstallabaqus-mtx-parserUsageRun the following script to parse the mtx fileinner.mtx.fromimportlib.resourcesimportfilesfromabaqus_mtx_parserimportparse_mtxmtx=files("abaqus_mtx_parser.mtx.unsymmetric").joinpath("inner.mtx")# Path to "inner.mtx"result=parse_mtx(mtx)print(result.nodes,# node numbers: [2, 3, 4, 5, 6, 7]result.dof,# node dofs: {2: [1, 2, 3, 4, 5, 6], 3: [1, 2, 3, 4, 5, 6], 4: [1, 2, 3, 4, 5, 6], 5: [1, 2, 3, 4, 5, 6], 6: [1, 2, 3, 4, 5, 6], 7: [1, 2, 3, 4, 5, 6]}result.stiffness,# stiffness matrix) |
abaqus-parse | abaqus-parseAbaqus input and output file readers and writers.Change Log[0.1.3] - 2021.08.10FixedFix dependencycalfem-python[0.1.2] - 2021.08.10AddedAdd various functions for generating input files for forming limit curve predictions via a grooved-sheet Marciniak-Kuczynski method.[0.1.1] - 2020.12.15Addedgenerate_compact_tension_specimen_parts,generate_compact_tension_specimen_stepscompact_tension_specimen_meshand additional helper mesh functionsChangedExtended capabilities ofwrite_inpand added docstring.[0.1.0] - 2020.11.16Initial release |
abaqustools | No description available on PyPI. |
abarms | What isabarms?abarmsis ahandySwiss-army-knife-like tool/utility/console app for POSIX-compatible systems for manipulating Android Backup files (*.ab,*.adb) produced byadb backup,bmgr, and similar tools.abarmscan list contents, convert Android Backup files into TAR files and back (by decrypting, decompressing, and re-compressing said files), and split full-system dumps produced byadb backupinto per-app backups that can be given toadb restore.Basically, this is a simpler pure Python implementation (only requiressetuptoolsandcryptographymodules) ofandroid-backup-extractorand the parts ofandroid-backup-toolkitandandroid-backup-processorthat I use myself.Why doesabarmsexists?(TL;DR: read the parts in bold.)Did you know that your Android OS device already has an awesome built-in full-system phone-to-PC backup and PC-to-phone restore tool that does not require root access?adbutility of Android Platform Tools hasadb backupsubcommand that, in principle, can do basically everything you could possibly want there.Internally this is implemented via Android OS setuid root binary namedbu--- which you can run manually viaadb shell bu help--- that simply backs up every app on the device one by one and streams the resulting.abfile --- which is a wrapped PAX-formatted TAR file (see "EXTENDED DESCRIPTION" section inman 1 pax) --- to stdout.adb backupsubcommand is just a simple wrapper around it.But then Android Platform Tools bundle gives no tools to manipulate those backup files!So, if you make a full-system backup withadb backup, and then want to restore a single app out of 100+ you have installed on your device, you need third-party tools now.
This is kind of embarrassing, to be honest.
A tool to manipulate backup files should have been a standard utility in Android Platform Tools since Android version 0.1 or something.
(Seriously, are you not embarrassed? I'm embarrassed for the state of humanity thinking about how the most popular OS on the planet gives no widely accessible local backup and restore tools on par with what every user of 1970s-era UNIX mainframe had out of the box. I'm not asking for automatic opportunistic incremental quantum-safely encrypted full-system replication to cooperative nearby devices in a local mesh-network here!)Well, technically speaking, Android OS also has automatic scheduled non-interactive backup servicebmgr--- which can be controlled via Android settings menu andadb shell bmgr help, that does per-app backups and restores.
Internally,bmgrservice also generates.abfiles and then either uploads them to Google --- which is the default and the only option available through the settings menu --- or stores them locally under/data/data/com.android.localtransport/files/--- which requires root to access.
On old Android versions you could askbmgrto do a backup to an SD card directly from the settings menu, but Google removed that functionality to force users to use Cloud-based backups.So, basically, according to Google (and Samsung, which ship with their ownbmgr-like service in parallel withbmgr), to restore to a previous state of an app, or to migrate between phones you now apparently have to upload all your data to their servers in plain-text for their convenient data-mining and selling of your data to interested third parties.
Google even went as far as to hideadb backupsubcommand from their official Android documentation: compare theold manual foradbwith thecurrent one, Control+F for "backup".This resulted into every Android vendor now making their own vendor-specific phone-to-phone migration utilities, and a whole ecosystem of commercial apps that do whatadb backupalready does, but worse.This also resulted in usefulness ofadb backupitself being reduced because in Android version 6 Google made automatic daily file-based backups that get uploaded to Google the default when you attach your phone to your Google account.
So, most apps started to opt-out of those backups for privacy and security reasons -- which also started opting them out of being included inadb backupoutput, sincebmgrandbushare most of the infrastructure.
Some of those apps now implement their own in-app backup buttons hidden away in the settings menu somewhere, but most do not.Yes, this is stupid, seethis discussion on StackOverflow.
See also old Android developer docs that explained this fairly clearlyhereandhere.(You can also force an app to be included inadb backupby rebuilding its APK to enableandroid:allowBackupattribute in the manifest and installing the result manually, seethisfor more info.
But this will only work for newly installed apps as you will have to re-sign the resulting APK with your own private key and Android forbids app updates that change the signing key.)But, hopefully, eventually, some alternative firmware developer will fix the above bug and allowadb backupto backup all apps regardless ofandroid:allowBackupmanifest setting, as it should.Still,adb backupworks fine for a lot of apps and, hopefully, will eventually get back to working as well as it did before Android version 6 in the future.
Meanwhile,android-backup-toolkitallows you to split full-system dumps produced byadb backupinto per-app backups that can then be restored withadb restore.The problem is that, while I'm thankful thatandroid-backup-toolkitexists, I find it really annoying to use: it is a bundle of pre-compiled Java apps, binaries, and shell scripts that manages to work somehow, but modifying anything there is basically impossible as building all of those things from sources is an adventure I failed to complete, and then you need to install the gigantic Java VM and libraries to run it all.So, as it currently stands, to have per-app backups of your Android device you have to either:root your device;give up your privacy by uploading your backups to other people's computers (aka "the cloud"); orrepack all you APKs withandroid:allowBackup = trueand either run older Android firmware that can do backup to an SD card or runadb backupfrom your PC, and then extract per-app backups from its output (yes, this is not ideal, but it works, and does not need root).So, one day I was looking at all of this.
I couldn't root or change the firmware on a phone I wanted to keep backed up, but I could follow the last option and get most of what I wanted with almost no effort.
Except figuring out how to runandroid-backup-toolkitto do the very last step of this took me quite a while.
And so I thought, "Hmm, this seems overly complicated, something as simple as splitting and merging TAR files with some additional headers should be doable with a simple Python program."
So I made one.It turned out to be a bit less simple than I though it would be, mostly because Python'starfilemodule was not designed for this, so I had to make my own, and PAX-formatted TAR files are kind of ugly to parse, but it works now, so, eh.Hopefully,abarmsexisting will inspire more app and alternative firmware developers to supportadb backupproperly and so personal computing devices of late 2020s will finally reach feature parity with 1970s-era Tape ARchiving (TAR) backup technology.QuickstartInstallationInstall with:pip install abarmsand run asabarms --helpAlternatively, install it via Nixnix-env -i -f ./default.nixAlternatively, run without installing:python3 -m abarms --helpBackup all apps from your Android device, then restore a single app, without rootPrepare your PC and phoneBefore you make a full backup of your Android phone (or other device) you need toinstall Android Platform Tools (either fromthereor from you distribution),enable Developer Mode and USB Debugging (seeAndroid Docsfor instructions).then, usually, on your PC you need to runsudo adb kill-server
sudo adb start-serverunless, you added special UDev rules for your phone.Do a full backupTo do the backup, you need to unlock your phone, connect your it to your PC via a USB cable (in that order, otherwise USB Debugging will be disabled), confirm that the PC is allowed to do USB Debugging in the popup on the phone, then runadb backup -apk -obb -noshared -all -system -keyvalueon your PC, then (unlock your phone again and) press "Back up my data" button at the bottom of your screen.Now you need to wait awhile foradbto finish.
The result will be saved inbackup.abfile.If you want to backup to an explicitly named file, e.g. to note the date of the backup, runadb backup -f backup_20240101.ab -apk -obb -noshared -all -system -keyvalueinstead.Split it into piecesYou can view contents of the backup viaabarms ls backup_20240101.aband split it into per-app backups viaabarms split backup_20240101.abwhich will produce a bunch of files namedabarms_split_<filename>_<num>_<appname>.ab(e.g.abarms_split_backup_20240101_020_org.fdroid.fdroid.ab).Restore a single appA single per-app file can be fed back toadb restoreto restore that singe app, e.g.adb restore abarms_split_backup_20240101_020_org.fdroid.fdroid.abRebuild full backup from partsYou can also rebuild the original full-backup from parts viaabarms merge abarms_split_backup_20240101_*.ab backup_20240101.rebuilt.abto check that it produces exactly the same backup file# strip encryption and compression from the original
abarms strip backup_20240101.ab backup_20240101.stripped.ab
# compare to the stipped original and the rebuilt file
diff backup_20240101.stripped.ab backup_20240101.rebuilt.ab || echo differAlternativesandroid-backup-toolkitand friendsandroid-backup-extractoris a Java app that can decrypt and decompress Android Backup archives and convert them into TAR.android-backup-toolkitbuilds on top ofandroid-backup-extractorand provides a way to split full-system backup ADB files into per-app pieces.android-backup-processoris an older version ofandroid-backup-toolkit.If you have root on your deviceAssuming you have root on your Android phone, you can do# check if bmgr is enabled
adb shell bmgr enabled
# list bmgr transports
adb shell bmgr list transports
# localtransport should be there, enable it
adb shell bmgr transport com.android.localtransport/.LocalTransport
# enable bmgr
adb shell bmgr enable true
# do a full backup now
adb shell bmgr fullbackupand then take per-app backup files from/data/data/com.android.localtransport/files/.QuirksThe precise algorithm for how encrypted Android Backup files get their master key salted checksums computed remains a mystery to me even after reading all the related Android sources.Luckily, those checksums verify that the given passphrase is correct and can be ignored while reading.abfiles since the following encrypted Android Backup headers are verbose enough that a wrong passphrase will break parsing anyway.
None of my use cases ever need encrypted.abfiles and no firmware I know of requiresadb restoreinputs to be encrypted.So, after spending two days trying to figure those checksums out I decided thatabarmsdoes not support generating encrypted.abfiles by design.
(You are welcome to try and implement this, see comments in the__main__.py.)If it isn't clear,abarmsdoessupport encrypted.abfiles as inputs (because my phone always generates such regardless of my wishes).LicenseGPLv3+, small library parts are MIT.UsageabarmsA handy Swiss-army-knife-like utility for manipulating Android Backup files (*.ab,*.adb) produced byadb backup,bmgr, and similar tools.options:--version: show program's version number and exit-h, --help: show this help message and exit--markdown: show help messages formatted in Markdownpassphrase:-p PASSPHRASE, --passphrase PASSPHRASE: passphrase for an encryptedINPUT_AB_FILE--passfile PASSFILE: a file containing the passphrase for an encryptedINPUT_AB_FILE; similar to-poption but the whole contents of the file will be used verbatim, allowing you to, e.g. use new line symbols or strange character encodings in there; default: guess based onINPUT_AB_FILEtrying to replace ".ab" and ".adb" extensions with ".passphrase.txt"subcommands:{ls,list,strip,ab2ab,split,ab2many,merge,many2ab,unwrap,ab2tar,wrap,tar2ab}ls (list): list contents of an Android Backup filestrip (ab2ab): strip encyption and compression from an Android Backup filesplit (ab2many): split a full-system Android Backup file into a bunch of per-app Android Backup filesmerge (many2ab): merge a bunch of Android Backup files into oneunwrap (ab2tar): convert an Android Backup file into a TAR filewrap (tar2ab): convert a TAR file into an Android Backup fileabarms lsList contents of an Android Backup file similar to howtar -tvfwould do, but this will also show Android Backup file version and compression flags.positional arguments:INPUT_AB_FILE: an Android Backup file to be used as input, set to "-" to use standard inputabarms stripConvert an Android Backup file into another Android Backup file with encryption and (optionally) compression stripped away.
I.e. convert an Android Backup file into a simple unencrypted (plain-text) and uncompressed version of the same.Versioning parameters and the TAR file stored inside the input file are copied into the output file verbatim.Useful e.g. if your Android firmware forces you to encrypt your backups but you store your backups on an encrypted media anyway and don't want to remember more passphrases than strictly necessary.
Or if you want to strip encryption and compression and re-compress using something better than zlib.positional arguments:INPUT_AB_FILE: an Android Backup file to be used as input, set to "-" to use standard inputOUTPUT_AB_FILE: file to write the output to, set to "-" to use standard output; default: "-" ifINPUT_TAR_FILEis "-", otherwise replace ".ab" and ".adb" extension ofINPUT_TAR_FILEwith.stripped.aboptions:-d, --decompress: produce decompressed output; this is the default-k, --keep-compression: copy compression flag and data from input to output as-is; this will make the output into a compressed Android Backup file if the source is compressed; this is the fastest way tostrip, since it just copies bytes around as-is-c, --compress: (re-)compress the output file; this could take awhileabarms splitSplit a full-system Android Backup file into a bunch of per-app Android Backup files.Resulting per-app files can be given toadb restoreto restore selected apps.Also, if you do backups regularly, then splitting large Android Backup files like this and then deduplicating per-app files between backups could save lots of disk space.positional arguments:INPUT_AB_FILE: an Android Backup file to be used as input, set to "-" to use standard inputoptions:--prefix PREFIX: file name prefix for output files; default:abarms_split_backupifINPUT_AB_FILEis "-",abarms_split_<INPUT_AB_FILE without its ".ab" or ".adb" extension>otherwise-c, --compress: compress per-app output filesabarms mergeMerge many smaller Android Backup files into a single larger one.
A reverse operation tosplit.This exists mostly for checking thatsplitis not buggy.positional arguments:INPUT_AB_FILE: Android Backup files to be used as inputsOUTPUT_AB_FILE: file to write the output tooptions:-c, --compress: compress the output fileabarms unwrapConvert Android Backup header into a TAR file by stripping Android Backup header, decrypting and decompressing as necessary.The TAR file stored inside the input file gets copied into the output file verbatim.positional arguments:INPUT_AB_FILE: an Android Backup file to be used as input, set to "-" to use standard inputOUTPUT_TAR_FILE: file to write output to, set to "-" to use standard output; default: guess based onINPUT_AB_FILEwhile setting extension to.tarabarms wrap --output-versionConvert a TAR file into an Android Backup file by prepending Android Backup header and (optionally) compressing TAR data with zlib (the only compressing Android Backup file format supports).The input TAR file gets copied into the output file verbatim.Note that the above means that unwrapping a.abfile, unpacking the resulting.tar, editing the resulting files, packing them back with GNUtarutility, runningabarms wrap, and then runningadb restoreon the resulting file will probably crash your Android device (phone or whatever) because the Android-side code restoring from the backup expects the data in the packed TAR to be in a certain order and have certain PAX headers, which GNUtarwill not produce.So you should only use this on files previously produced byabarms unwrapor if you know what it is you are doing.Production of encrypted Android Backup files is not supported at this time.positional arguments:INPUT_TAR_FILE: a TAR file to be used as input, set to "-" to use standard inputOUTPUT_AB_FILE: file to write the output to, set to "-" to use standard output; default: "-" ifINPUT_TAR_FILEis "-", otherwise replace ".ab" and ".adb" extension ofINPUT_TAR_FILEwith.aboptions:--output-version OUTPUT_VERSION: Android Backup file version to use (required)-c, --compress: compress the output fileUsage notesGiving an encryptedINPUT_AB_FILEas input, not specifying--passphraseor--passfile, and not having a file named{INPUT_AB_FILE with ".ab" or ".adb" extension replaced with ".passphrase.txt"}in the same directory will case the passphrase to be read interactively from the tty.ExamplesList contents of an Android Backup file:abarms ls backup.abUsetarutil to list contents of an Android Backup file instead of runningabarms ls:abarms unwrap backup.ab - | tar -tvf -Extract contents of an Android Backup file:abarms unwrap backup.ab - | tar -xvf -Strip encryption and compression from an Android Backup file:# equivalent
abarms strip backup.ab backup.stripped.ab
abarms strip backup.ab# equivalent
abarms strip --passphrase secret backup.ab
abarms strip -p secret backup.ab# with passphrase taken from a file
echo -n secret > backup.passphrase.txt
# equivalent
abarms strip backup.ab
abarms strip --passfile backup.passphrase.txt backup.ab# with a weird passphrase taken from a file
echo -ne "secret\r\n\x00another line" > backup.passphrase.txt
abarms strip backup.abStrip encryption but keep compression, if any:# equivalent
abarms strip --keep-compression backup.ab backup.stripped.ab
abarms strip -k backup.abStrip encryption and compression from an Android Backup file and then re-compress usingxz:abarms strip backup.ab - | xz --compress -9 - > backup.ab.xz
# ... and then convert to tar and list contents:
xzcat backup.ab.xz | abarms unwrap - | tar -tvf -Convert an Android Backup file into a TAR archive:# equivalent
abarms unwrap backup.ab backup.tar
abarms unwrap backup.abConvert a TAR archive into an Android Backup file:# equivalent
abarms wrap --output-version=5 backup.tar backup.ab
abarms wrap --output-version=5 backup.tar |
abasepy11 | No description available on PyPI. |
abasepyfinal | Failed to fetch description. HTTP Status Code: 404 |
abasepyplatforms | No description available on PyPI. |
abasepytest | Platform Specific WheelNoteThis package currently only support on python version 3.10 or lower , because pyarmor module is still in development for version 3.11 or higher , so you need to wait for upgrading your virtual_environment to python 3.11This package does not need platform specific wheel it runs on devices that have python. currently it is OS independentIMPORTANTpython is intrepreter language , hiding its source code from public is not easy , we are taking difficult path to hide by using pyarmor module , we are using trial version and it can only take upto 8000 lines of code i think , you need to be updated on changes that happen to pyarmor modules and its bugs and fixesPyPi is open-source distribution , so source will be visible , we are just only encrypting it.
If you are ok with Users or Developers seeing the source code but not public , you can just share the wheel file that have extension .whl to the users without being to uploading into PyPi repo(it is meant for open source distributers) . So in this way you can remove the use of pyarmor encryptionSteps To Reproduceinstall pyarmorpip install pyarmormake sure your python version is 3.10 or belowpython --versionFILE STRUCTURENow run pyarmor on project folderpyarmor gen --obf-mod=1 .if it is successful there should be dist folderdist folder will contains two folderpyarmor_runtime_00000andsrcreplace orginalsrcfolder withsrcfolder in dist folder. you can see codes insrcfolder in dist is in encrypted formmovepyarmor_runtime_00000folder to src folderdeletedistfoldernow your file structure should be like thisnow open pyproject.toml file and type thischeck your file structure for any mistakesnow run this in parent directorypython -m build wheel.this will create adistfolder that contains wheel fileyou can now share this wheel file to users you want , without having to uploading into PyPIImporting the Packagefrom package_name.base import DatabaseConnector , AgentRunnerUploading to PyPIThe first thing you’ll need to do is register an account on PyPI, To register an account, go tohttps://pypi.org/account/register/and complete the steps on that page. You will also need to verify your email address before you’re able to upload any packages.To securely upload your project, you’ll need a PyPIAPI token. Create one athttps://pypi.org/manage/account/#api-tokens, setting the “Scope” to “Entire account”.Don’t close the page until you have copied and saved the token — you won’t see that token again.Now that you are registered, you can usetwineto upload the distribution packages. You’ll need to install Twine:Installing twinepython3 -m pip install --upgrade twineUploading with twineOnce installed, run Twine to upload all of the archives underdist:run this command on package directorypython3 -m twine upload --repository pypi dist/*You will be prompted for a username and password. For the username, use__token__. For the password, use the token value (API token that created in PyPI earlier), including thepypi-prefix.Once uploaded your package should be visible on PyPI . Try to install it from thereUploading to PyPi with wheeldownload the wheel file i send to youyou only need the wheel file for this , you don't need other project filesThe first thing you’ll need to do is register an account on PyPI, To register an account, go tohttps://pypi.org/account/register/and complete the steps on that page. You will also need to verify your email address before you’re able to upload any packages.To securely upload your project, you’ll need a PyPIAPI token. Create one athttps://pypi.org/manage/account/#api-tokens, setting the “Scope” to “Entire account”.Don’t close the page until you have copied and saved the token — you won’t see that token again.Now that you are registered, you can usetwineto upload the distribution packages. You’ll need to install Twine:Installing twinepython3 -m pip install --upgrade twineUploading with twineOnce installed, run Twine to upload all of the archives underdist:run this command on folder that contains download wheel filepython3 -m twine upload --repository pypi *type wheel name here*You will be prompted for a username and password. For the username, use__token__. For the password, use the token value (API token that created in PyPI earlier), including thepypi-prefix.Once uploaded your package should be visible on PyPI . Try to install it from thereIMPORTANTif some issue persist in future , try downgrading pyarmor , and build the package by referring above steps to reproduce ,
there is change in pyarmor commands . refer to pyarmor docs |
abate | No description available on PyPI. |
abathur | Simple Template manager to manage template and create project based on template.RequirementsPython 3.6+Works on Linux, Windows, Mac OSX, BSDInstallpip:pip install abathurUsagePresume you have a template like this:template/src
├── main
│ ├── java
│ │ └── com
│ │ └── abathur
│ │ └── {PROJECT_NAME}
│ │ └── {PROJECT_NAME_IN_CLASS}Application.java
│ │ ├── domain
│ │ │ ├── entity
│ │ │ │ └── {PROJECT_NAME_IN_CLASS}.java
│ │ │ ├── repository
│ │ │ │ └── {PROJECT_NAME_IN_CLASS}Repository.java
│ │ │ └── service
│ │ │ └── {PROJECT_NAME_IN_CLASS}Service.java
│ │ ├── facade
│ │ │ ├── {PROJECT_NAME_IN_CLASS}DtoMapper.java
│ │ │ └── {PROJECT_NAME_IN_CLASS}Facade.java
│ │ ├── infrastructure
│ │ │ └── persistence
│ │ │ ├── {PROJECT_NAME_IN_CLASS}Po.java
│ │ │ └── {PROJECT_NAME_IN_CLASS}Repository.java
│ │ └── resource
│ │ └── {PROJECT_NAME_IN_CLASS}Resource.java
│ └── resources
│ └── application.yml
└── test
├── java
│ └── com
│ └── abathur
│ └── {PROJECT_NAME}
│ └── resource
│ └── {PROJECT_NAME_IN_CLASS}ResourceTest.java
└── resourcesYou can put all placeholders surrounding with {} like {PROJECT_NAME} and {PROJECT_NAME_IN_CLASS} in the file sources and directory, you can write a file named.abathurin the root path like:cat .abathur
PROJECT_NAME_IN_CLASS
TABLE_NAME.abathurinclude all keywords used in template and split with n, abathur will load it and surround the with {}(Abathur would auto addPROJECT_NAMEinto keyword list), thenCreate alias:abathur add alias ~/templateBuild project based on template:abathur build -a name project_nameWhen build project, abathur will let user fix replace the words notified in.abathurand replace the placeholders in template.You can use –output special the project path.You can use –config special a config file auto fill replaceholdersList aliases:abathur listRemove alias:abathur remove alias |
abatools | Android Boot Animation ToolsSimple command line utility for working with Android Boot AnimationsThis utility is made to simplify the process of creating Android-ready bootanimation.zip filesTo install:Clone this git repository, and from the top-level directory (where setup.py is):pip3 install .Alternatively, you can get the package from PyPi using:pip3 install abatoolsOnce installed, the abatools utility should be available from the command line. Example:abatools -a bootanimation.zipHelp is available from the command line with the -h or --help option, but basic usage is as follows:-a [filename.zip] zip all files/folders in current directory totarget [filename.zip]
-g [[gif file] [filename] [[gif file] [filename] ...]]
creates a boot animation from a target .gif and saves it to [filename.zip]Questions or comments can be directed [email protected]. Pull requests are welcome if you discover any issues.Copyright [2020] [Michael Podrybau]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied. See the License for the specific language governing
permissions and limitations under the License. |
abattlemetrics | abattlemetricsAn asyncio wrapper for the battlemetrics API.InstallationTo install the latest release from PyPI (requires Python 3.8 or above):pipinstallabattlemetricsTo install the development version from GitHub (requires Git):pipinstallgit+https://github.com/thegamecracks/abattlemetricsNoticeI am currently not maintaining this project as this wrapper has
been sufficient for my needs. Many endpoints have not been implemented,
but I will still accept PRs following thecontributing guide.LicenseThis project uses theMITlicense. |
abaxai-speech-client | Project descriptionThis is the speech client python package built by Abax.AIIt allows use to use speech to text services in both manners: offline and onlineOnline streaming will take audio stream in realtime, and return the transcripts on the flyOffline transcribing will read your audio file, transcribe and return the transcripts in different formats.ExamplesStream your audio file with python3import io
from abaxai_sdk import streaming
accessToken = 'YOUR_ACCESS_TOKEN'
def get_wav_data(wavfile):
for block in iter(lambda: wavfile.read(1280), b""):
yield generate_block(block)
def generate_block(block):
return block
def abaxai_streaming(stream_file):
"""Streams transcription of the given audio file."""
client = streaming.SpeechClient()
config = streaming.RecognitionConfig(
encoding=streaming.AudioEncoding.LINEAR16,
sample_rate_hertz=16000,
language_code="en-US",
model="basic_english",
)
streaming_config = streaming.StreamingRecognitionConfig(config, accessToken)
# In practice, stream should be a generator yielding chunks of audio data.
with io.open(stream_file, 'rb') as audiostream:
data = get_wav_data(audiostream)
requests = (
streaming.StreamingRecognizeRequest(audio_content=chunk) for chunk in data
)
responses = client.streaming_recognize(
config=streaming_config,
requests=requests,
)
print("\n\nFinal transcripts: \n")
for response in responses:
print(response)
audio_file = "your_audio_file.wav"
print("Streaming the audio file")
abaxai_streaming(audio_file)Transcribe your audio file with python3from abaxai_sdk import transcribing
accessToken = 'YOUR_ACCESS_TOKEN'
def abaxai_transcribe(audio_filepath):
"""Streams transcription of the given audio file."""
client = transcribing.SpeechClient()
config = transcribing.RecognitionConfig(
encoding=transcribing.AudioEncoding.LINEAR16,
sample_rate_hertz=16000,
language_code="en-US",
model="wenet-english",
)
transcribing_config = transcribing.TranscribeConfig(config, accessToken)
client.recognize(config=transcribing_config,
audiofilepath=audio_filepath,)
# speechid = "<your_speech_id>"
# client.get_transcription(speechid, accessToken)
print("Done.")
audio_file = "your_audio_file.wav"
print("Transcribe the audio file")
abaxai_transcribe(audio_file)ResourcesHomepage:https://abax.ai/ |
abayestest | ABayesTestABayesTest is a lightweight Python package for performing Bayesian AB testing.
Computations are run usingStanviacmdstanpy, andjinja2is used
as a backend templating engine
to construct the Stan model files.InstallationTo install, use:python3.10-mpipinstallgit+ssh://[email protected]/cmgoold/abayestest.gitInstalling ABayesTest will also create a local cache folder for storing
Stan model objects, which is.abayesin the repository root.CmdStanABayesTest requires a workingcmdstaninstallation. The easiest
way to downloadcmdstanisviacmdstanpy.Simple APIThe simplest use-case is running a comparison
between two sets of approximately normally-distributed
data sets. First, let's sample some fake data, where
we have two groups with the following data generating
process:$$
\begin{align}
y_{ij} &\sim \mathrm{Normal}(\mu_{j}, \sigma_{j})\
\mu_{A} &= 0, \quad \sigma_{A} = 0.2 \
\mu_{B} &= 1, \quad \sigma_{B} = 1
\end{align}
$$That is, both groups' data are normally distributed
with locations,0and1, and scales0.2and1, respectively.
Thus, there is a true difference of means of-1and
a true difference of scales of-0.8. Here's the Python
code:importnumpyasnpfromabayestestimportABayesTestSEED=1234rng=np.random.default_rng(SEED)N=100mu=[0,1]sigma=[0.2,1]y_a=rng.normal(size=N,loc=mu[0],scale=sigma[0])y_b=rng.normal(size=N,loc=mu[1],scale=sigma[1])We then initialize anABayesTestobject with the default options
(normal likelihood, default priors) and fit the model, passing
the data in as a tuple:ab=ABayesTest(seed=SEED)ab.fit(data=(y_a,y_b))The model will run in Stan and returnself.
You can access thecmdstanpy.CmdStanMCMCobject
itself usingab.cmdstan_mcmc.
For instance, we can usecmdstanpy's diagnostic
function to check for any convergence problems:ab.diagnose()which returns:Checking sampler transitions treedepth.
Treedepth satisfactory for all transitions.
Checking sampler transitions for divergences.
No divergent transitions found.
Checking E-BFMI - sampler transitions HMC potential energy.
E-BFMI satisfactory.
Effective sample size satisfactory.
Split R-hat values satisfactory all parameters.
Processing complete, no problems detected.indicating no problems.To inspect the results, runab.summary(), which returns
a summary PandasDataFramestraight fromArviz:mean sd hdi_3% hdi_97% mcse_mean mcse_sd ess_bulk ess_tail r_hat
mu[0] 0.026 0.023 -0.018 0.067 0.000 0.000 4655.0 3215.0 1.0
mu[1] 1.059 0.105 0.851 1.249 0.001 0.001 5554.0 3166.0 1.0
mu_diff -1.033 0.108 -1.222 -0.820 0.001 0.001 5566.0 3225.0 1.0
mu_star[0] 0.026 0.023 -0.018 0.067 0.000 0.000 4655.0 3215.0 1.0
mu_star[1] 1.059 0.105 0.851 1.249 0.001 0.001 5554.0 3166.0 1.0
mu_star_diff -1.033 0.108 -1.222 -0.820 0.001 0.001 5566.0 3225.0 1.0
sigma[0] 0.229 0.016 0.199 0.259 0.000 0.000 4938.0 3202.0 1.0
sigma[1] 1.046 0.077 0.904 1.190 0.001 0.001 4530.0 2968.0 1.0
sigma_diff -0.817 0.078 -0.973 -0.681 0.001 0.001 4504.0 3051.0 1.0
sigma_star[0] -1.478 0.071 -1.616 -1.349 0.001 0.001 4938.0 3202.0 1.0
sigma_star[1] 0.042 0.073 -0.101 0.174 0.001 0.001 4530.0 2968.0 1.0
sigma_star_diff -1.520 0.101 -1.709 -1.334 0.001 0.001 4755.0 3271.0 1.0ABayesTest always uses the parametermuto refer to
the vector of group-specific locations, or other non-normal
distribution's canonincal parameters (e.g. the Poisson
rate parameter; see below). Dispersion parameters,
such as the normal distribution's scale parameter,
are referred to assigma.The parameters suffixed with_starare unconstrained
parameters, which ABayesTest uses for estimation under-the-hood.
More details about the parameter transformations and
likelihood parameterisations are given below, but
for the normal distribution,mu = mu_starandsigma_star = log(sigma).
Conditions A and B are always indexed as0and1in the Python outputs.
The additional variablesmu_diffandsigma_diff(and
the_starcompanions) give
the difference in posterior distributions between groups 1 and 2
(i.e.mu[0] - mu[1]using Python's zero-indexing).
As we can see, these recover the data-generating assumptions above,
with posterior means close to-1and-0.8for the means
and standard deviations, respectively.Using the estimated quantities, users can calculate
any quantities or metrics that are meaningful
to the AB test being performed. For instance,
the probability that condition B scores greater than
A is the proportion of the posterior distribution
ofmu[1] - mu[0]that is greater than zero,
which in this case is 100%, as can be inferred
from themu_diffdistribution directly:importmatplotlib.pyplotaspltfromscipy.statsimportgaussian_kdedefdensity(x):limits=x.min(),x.max()grid=np.linspace(*limits,1000)returngrid,gaussian_kde(x)(grid)mu_diff=ab.draws()["mu_diff"]plt.plot(*density(mu_diff),color="#0492c2",lw=4)plt.axvline(0,ls=":",color="gray")plt.xlabel("score")plt.ylabel("density")plt.title("posterior of condition A - B")TheABayesTestclass also contains a handy method
to report the distribution of
differences in the posteriors
between conditions calledcompare_conditions, which
tells us that:100.00% of the posterior differences for mu favour condition B.
100.00% of the posterior differences for sigma favour condition B.Posterior predictive distributionABayesTest automatically calculates the posterior predictive
distribution of the data, which is accessible in
the posterior draws object under the keyy_rep.
This array is in long form, where group A and B's
predictions are stacked on top of each other.
Using the example above, we can inspect this
distribution using some small manipulation
of the posterior draws:y_rep_raw=ab.draws()["y_rep"]y_reps=y_rep_raw[:,:N],y_rep_raw[:,N:]ys=y_a,y_bfig,ax=plt.subplots(1,2,figsize=(12,4))foriinrange(2):a_or_b=(1-i)*"A"+i*"B"grid,samples=density(y_reps[i].flatten())ax[i].plot(grid,samples,color="#0492c2",lw=3,label="Posterior predictive")ax[i].plot(ys[i],[0.01]*len(ys[i]),'|',color="black",label="raw")ax[i].set_title(a_or_b)ax[i].set_xlabel("score")ax[i].set_ylabel("density")ifnoti:ax[i].legend(frameon=False,loc="upper right")The rug plots show that the observed data fall within
the posterior predictive densities.Likelihood functionsCurrently, ABayesTest supports normal, lognormal, gamma,
Bernoulli, binomial, and Poisson distributions.For non-normal likelihood functions, ABayesTest
calculates the differences in canonical
parameters on both unconstrained and
original scales.
The table below illustrates how each
likelihood distribution is parameterised,
what link functions are used to transform
the parameters to the unconstrained scale,
and the name of the unconstrained and
original-scale parameters, for reference.DistributionParameterizationLink function transformsnormalmean, sdmean :=mu = mu_starsd :=sigma = exp(sigma_star)lognormallog-scale mean, log-scale sdmean :=mu = mu_starsd :=sigma = exp(sigma_star)gammashape, rateshape :=mu^2 / sigma^2 = exp(mu_star)^2 / exp(sigma_star)^2rate :=shape / mu = shape / exp(mu_star)Poissonraterate :=mu = exp(mu_star)Bernoulliprobabilityprobability :=mu = logit^-1(mu_star)binomialprobabilityprobability :=mu = logit^-1(mu_star)ABayesTest will always return themu,mu_star,sigmaandsigma_starparameters,
and their posterior differences, as standard.
Additional variables appended with_jindicate the long-form parameter vectors,
i.e. the value of the parameters at each index or case in the data.All but the binomial likelihood require the same data format as above. That is,
the normal, lognormal, gamma, poisson, and bernoulli models just require
theydata vectors as a tuple, or alternatively as a dictionary.
The binomial likelihoods require an additional data vector for thenparameter in thebinomial PMF. It's assumed that the data for binomial models
enter as a tuple or dictionary of tuples, in the
form ofdata=( (n1, y1), (n2, y2) ).Taking a specific example, below we simulate binomial
data and it a model:N=500mu=[0.6,0.9]n=rng.choice(range(70,100),N)y1=rng.binomial(n=n,size=N,p=mu[0])y2=rng.binomial(n=n,size=N,p=mu[1])data=(n,y1),(n,y2)binomial=ABayesTest(likelihood="binomial",seed=SEED)binomial.fit(data)binomial.summary()mean sd hdi_3% hdi_97% mcse_mean mcse_sd ess_bulk ess_tail r_hat
mu[0] 0.596 0.002 0.592 0.601 0.0 0.0 3597.0 2533.0 1.0
mu[1] 0.898 0.001 0.896 0.901 0.0 0.0 3186.0 2305.0 1.0
mu_diff -0.302 0.003 -0.307 -0.297 0.0 0.0 3570.0 2501.0 1.0
mu_star[0] 0.391 0.010 0.371 0.408 0.0 0.0 3597.0 2533.0 1.0
mu_star[1] 2.179 0.016 2.149 2.209 0.0 0.0 3186.0 2305.0 1.0
mu_star_diff -1.788 0.019 -1.823 -1.753 0.0 0.0 3374.0 2422.0 1.0Here, themu_diffparameter tells us that the mean posterior differences
is-0.3, which is exactly what we simulated.Priors and prior predictive simulationsThe default priors are all standard normals on the unconstrained scales,
which can be inspected using:fromabayesimportDEFAULT_PRIORSDEFAULT_PRIORSreturning:'normal': {'mu_star': 'normal(0, 1)', 'sigma_star': 'normal(0, 1)'},
'lognormal': {'mu_star': 'normal(0, 1)', 'sigma_star': 'normal(0, 1)'},
'gamma': {'mu_star': 'normal(0, 1)', 'sigma_star': 'normal(0, 1)'},
'poisson': {'mu_star': 'normal(0, 1)'},
'bernoulli': {'mu_star': 'normal(0, 1)'},
'binomial': {'mu_star': 'normal(0, 1)'}}These priors are generally weakly informative,
but can be changed to any Stan probability
distributions you like.
At the moment, different priors for
each group, or hierarchical structures,
are not supported.ABayesTest also supports running prior
predictive simulations using theprior_onlyflag passed to the
class constructor:rng=np.random.default_rng(SEED)N=100mu=[0,1]sigma=[0.2,1]y1=rng.normal(size=N,loc=mu[0],scale=sigma[0])y2=rng.normal(size=N,loc=mu[1],scale=sigma[1])prior=ABayesTest(prior_only=True,seed=SEED)prior.fit((y1,y2))y_rep_raw_prior=prior.draws()["y_rep"]y_reps_prior=y_rep_raw_prior[:,:N],y_rep_raw_prior[:,N:]ys=y1,y2fig,ax=plt.subplots(1,2,figsize=(12,4))foriinrange(2):a_or_b=(1-i)*"A"+i*"B"grid,samples=density(y_reps[i].flatten())prior_grid,prior_samples=density(y_reps_prior[i].flatten())ax[i].plot(grid,samples,color="green",lw=3,label="Posterior predictive")ax[i].plot(prior_grid,prior_samples,color="#0492c2",lw=3,label="Prior predictive")ax[i].plot(ys[i],[0.01]*len(ys[i]),'|',color="black",label="raw")ax[i].set_title(a_or_b)ax[i].set_xlabel("score")ax[i].set_ylabel("density")ax[i].set_xlim((-20,20))ifnoti:ax[i].legend(frameon=False,loc="upper right")The above plot shows the prior predictive distribution
in blue and posterior predictive distribution
from the first example above in green.Raw Stan codeThe 'private' attribute_render_modelcan be used, if interested, to see the raw Stan code:ab._render_model() |
abba-python | ABBA PythonAligning Big Brains and Atlases, controlled from Python.Free software: GNU General Public License v3Documentation:https://biop.github.io/ijp-imagetoatlas/ABBA in briefAligning Big Brains & Atlases, abbreviated as ABBA, allows you to register thin serial sections to multiple atlases in coronal, sagittal, and horizontal orientations. It is mainly a Java application, but this repo makes all of its API accessible in Python.With ABBA Python, you can control ABBA API from python, and get some additional perks. In particular you get access to allBrainGlobe atlases.[!WARNING]
Due to some threading issues, the GUI does not work with MacOSXGetting startedInstallminicondaorminiforge.Create a conda environment with Python 3.8, pyimagej, OpenJDK 8 and maven and activate itInstall abba_pythonmamba create -c conda-forge -n abba-env python=3.8 openjdk=8 pip maven pyimagej
conda activate abba-env
pip install abba_pythonTo begin using ABBA with a graphical user interface (GUI):In the created environment, launch Python and run the following commands:from abba_python import abba
abba.start_imagej()You can then use ABBA within Fiji; for more details, visithttps://biop.github.io/ijp-imagetoatlas/.
ABBA is typically used in conjunction withQuPath: a QuPath project can serve as input for ABBA, and the registration results can be imported back into QuPath for further processing.To begin with ABBA with jupyter labIn the created environment, installjupyterlabandipywidgets:pip install jupyterlab
pip install ipywidgetsYou can now runjupyter laband start using notebooks, like the ones provided in examples in the github repo.Installing extra modulesElastix/TransformixABBA's automated in-plane registration relies onelastix 5.0.1. To utilize all of ABBA's functionalities, you need to separately install elastix and transformix on your operating system. During the initial run of ABBA, you will be prompted to specify their executable locations. Alternatively, you can set their paths using the API (refer to thefirst example notebook).DeepSliceABBA can leverage the deep-learning registration toolDeepSlice, either through the web interface (in the GUI) or by running it locally. To use DeepSlice locally, you must install it in a separate conda environment and specify its path to ABBA, either through the GUI or the API (as explained in thefirst example notebook).Note that DeepSlice can also be used locally with the pure Java version thanks to this (new) design.To install DeepSlice, please refer to the documentation.In Sept 2023, this was working:conda create -n deepslice python=3.7
conda activate deepslice
conda install pip
pip install DeepSlice==1.1.5
pip install urllib3==1.26.6 # see https://github.com/PolarBean/DeepSlice/issues/46You also need to make conda available at the system level:
You need to follow this two steps procedure to enable Windows to use conda from cmd.exe:Into the environment variable, edit PATH, add path to your ..\Anaconda3\condabin default would be C:\ProgramData\Anaconda3\condabinOpen a new PowerShell (and/or PowerShell (x86) ), run the following command once to initialize conda:conda initNote on versionsOpenJDK versions above 8 can work, but they have been less tested, so there may be unexpected bugs. To avoidcertificate issues, it is recommended to have openjdk installed from conda-forge.CreditsThis package was created with Cookiecutter and theaudreyr/cookiecutter-pypackageproject template.Cookiecutteraudreyr/cookiecutter-pypackage |
abb-assetvista-avtypes | No description available on PyPI. |
abbccd | TestPackageNone |
ab-biga | No description available on PyPI. |
ab-ble-gateway-sdk-python | UNKNOWN |
abb-motion-program-exec | abb_motion_program_execabb_motion_program_execprovides a simple way to download and run a sequence ofMoveAbsJ,MoveJ,MoveL,MoveC, andWaitTimecommands on
an ABB IRC5 robot controller. This program is intended to be a proof of
concept for more sophisticated controller interfaces. Multi-move control of two robots is also
supported. Externally Guided Motion (EGM) is also supported for joint target, pose target, and path correction modes.Documentation can be found at:https://abb-motion-program-exec.readthedocs.io/Installationabb-motion-program-execis avaliable on PyPi.pip install abb-motion-program-execBegin by installing the software for the robot controller. This software can be
installed manually by copying files to the robot controller and importing configuration files.Seerobot_setup_manual.mdfor setup instructions.Seerobot_multimove_setup_manual.mdfor ABB Multi-Move
setup to control two robots. See later sections of this doc for more information on Multi-Move.This contains the robot-side code, that reads
and executes the contents ofmotion_program.bin.motion_program.bincontains the sequence of instructions to run, encoded in binary
format for fast interpretation.Only one instance of a Robot Studio virtual controller can be run at a time.Only
instances of Robot Studio can be run at a time running a single virtual controller. This is due to
the controller using TCP port 80 on the local computer to accept REST commands from Python. If
more than one controller is started, TCP port 80 will already be in use and can cause unpredictable
behavior. Restart the computer if connections cannot be made from Python to the controller. Multiple
real robots can be used concurrently since they will each have a unique IP address to bind port 80.Python 3.6 Linux Install (Ubuntu Bionic)Older versions of Python are not supported by the currently available protobuf package. Use the apt version instead.sudo apt install python3-virtualenv python3-protobuf python3-numpy python3-wheel python3-setuptools
python3 -m pip install --user abb-motion-program-execUsageOnce theabb_motion_program_exec.modhas been loaded on the controller,
the Python module can be used to command motion sequences. The classMotionProgramcontains is used to build the sequence of motions. It has
the following commands of interest:MoveAbsJ(to_joint_pos: jointtarget, speed: speeddata, zone: zonedata)- Move the
robot to a specified joint waypoint.MoveJ(to_point: robtarget, speed: speeddata, zone: zonedata)- Move the
robot to the specified Cartesian target using joint interpolation.MoveL(to_point: robtarget, speed: speeddata, zone: zonedata)- Move
the robot to the specified Cartesian target using linear interpolation.MoveC(cir_point: robtarget, to_point: robtarget, speed: speeddata, zone: zonedata)-
Move the robot to the specified Cartesian target circularly using an intermediate
waypoint.WaitTime(t: float)- Wait a specified time in seconds.Calling each of these functions adds the command to the sequence.The constructor forMotionProgramoptionally takes atoolparameter.
This parameter is expected to be typetooldataand will be passed
to each of the move commands. Because the tool is expected to be aPERStype by the ABB software, it can't be modified for each
motion command without a significant performance penalty.my_motion_program=MotionProgram(tool=my_tool)The following types are defined as subclasses ofNamedTuple:classspeeddata(NamedTuple):v_tcp:floatv_ori:floatv_leax:floatv_reax:floatclasszonedata(NamedTuple):finep:boolpzone_tcp:floatpzone_ori:floatpzone_eax:floatzone_ori:floatzone_leax:floatzone_reax:floatclassjointtarget(NamedTuple):robax:np.ndarray# shape=(6,)extax:np.ndarray# shape=(6,)classpose(NamedTuple):trans:np.ndarray# [x,y,z]rot:np.ndarray# [qw,qx,qy,qz]classconfdata(NamedTuple):cf1:floatcf4:floatcf6:floatcfx:floatclassrobtarget(NamedTuple):trans:np.ndarray# [x,y,z]rot:np.ndarray# [qw,qx,qy,qz]robconf:confdata#extax:np.ndarray# shape=(6,)classloaddata(NamedTuple):mass:floatcog:np.ndarray# shape=(3,)aom:np.ndarray# shape=(4,)ix:floatiy:floatiz:floatclasstooldata(NamedTuple):robhold:booltframe:posetload:loaddataSee the ABB Robotics manual "Technical reference manual RAPID
Instructions, Functions and Data types" for more details on these data
types. Note thatpos,orient,robjoint, andextjointare
implemented using numpy arrays or lists.The following standardspeeddataare available in the module:v5,v10,v20,v30,v40,v50,v60,v80,v100,v200,v300,v400,v500,v600,v800,v1000,v1500,v2000,v2500,v3000,v4000,v5000,v6000,v7000,vmax.The following standardzonedataare available in the module:fine,z0,z1,z5,z10,z15,z20,z30,z40,z50,z60,z80,z100,z150,z200.The followingtooldataare available in the module:tool0Once the program is complete, it can be executed on the robot usingMotionProgramExecClient. The constructor is by default:mp_client = MotionProgramClient(base_url='http://127.0.0.1:80', username='Default User', password='robotics')Thebase_url,username, andpasswordshould be adjusted to the actual robot. The
client using ABB Web Services.base_urlmust be set to the IP address of the
robot, or usinglocalhostif using the simulator.Once the client is constructed, it can be used to execute the program:log_results=mp_client.execute_motion_program(mp)log_resultsis a tuple containing the results of the motion:classMotionProgramResultLog(NamedTuple):timestamp:strcolumn_headers:List[str]data:np.arraytimestampis a string timestamp for the data.column_headersis a list of strings containing the labels of the
columns of data.datacontains a float32 numpy 2D array of the data, with each row being a sample.For a single robot, the data has the following columns:timestamp- The time of the row. This is time from the startup of the logger task in seconds.
Subtract the initial time from all samples to get a 0 start time for the program.cmd_num- The currently executing command number. Useget_program_rapid()to print out
the program with command numbers annotated.J1- Joint 1 position in degreesJ2- Joint 2 position in degreesJ3- Joint 3 position in degreesJ4- Joint 4 position in degreesJ5- Joint 5 position in degreesJ6- Joint 6 position in degreesThe fieldcolumn_headerscontains a list of the column headers.Python module installationTheabb_motion_program_execmodule is available on PyPI and can be installed using pip:pip install abb_motion_program_execFor development, use of avirtualenvis recommended. Use editable install with the virtualenv:pip install -e .Externally Guided Motion (EGM)Seeegm.mdfor instructions on using EGM.Exampleimportabb_motion_program_execasabbj1=abb.jointtarget([10,20,30,40,50,60],[0]*6)j2=abb.jointtarget([-10,15,35,10,95,-95],[0]*6)j3=abb.jointtarget([15,-5,25,83,-84,85],[0]*6)my_tool=abb.tooldata(True,abb.pose([0,0,0.1],[1,0,0,0]),abb.loaddata(0.001,[0,0,0.001],[1,0,0,0],0,0,0))mp=abb.MotionProgram(tool=my_tool)mp.MoveAbsJ(j1,abb.v1000,abb.fine)mp.MoveAbsJ(j2,abb.v5000,abb.fine)mp.MoveAbsJ(j3,abb.v500,abb.fine)mp.MoveAbsJ(j2,abb.v5000,abb.z50)mp.MoveAbsJ(j3,abb.v500,abb.z200)mp.MoveAbsJ(j2,abb.v5000,abb.fine)mp.WaitTime(1)r1=abb.robtarget([350.,-100.,600.],[0.0868241,-0.0868241,0.9924039,0.0075961],abb.confdata(-1,0,-1,0),[0]*6)r2=abb.robtarget([370.,120.,620.],[0.0868241,0.0868241,0.9924039,-0.0075961],abb.confdata(0,-1,0,0),[0]*6)r3=abb.robtarget([400.,-200.,500.],[0.7071068,0.,0.7071068,0.],abb.confdata(-1.,-3.,2.,0.),[0]*6)r4=abb.robtarget([400.,0.,580.],[0.7071068,0.,0.7071068,0.],abb.confdata(0.,-3.,2.,0.),[0]*6)r5=abb.robtarget([400.,200.,500.],[0.7071068,0.,0.7071068,0.],abb.confdata(0.,-2.,1.,0.),[0]*6)mp.MoveJ(r1,abb.v500,abb.fine)mp.MoveJ(r2,abb.v400,abb.fine)mp.MoveJ(r1,abb.v500,abb.z100)mp.MoveJ(r2,abb.v400,abb.z100)mp.MoveJ(r1,abb.v500,abb.fine)mp.WaitTime(1.5)mp.MoveJ(r3,abb.v5000,abb.fine)mp.MoveL(r4,abb.v200,abb.fine)mp.MoveL(r3,abb.v200,abb.fine)mp.MoveL(r4,abb.v1000,abb.z100)mp.MoveL(r3,abb.v1000,abb.z100)mp.MoveL(r4,abb.v1000,abb.fine)mp.WaitTime(2.5)mp.MoveJ(r3,abb.v5000,abb.fine)mp.MoveC(r4,r5,abb.v200,abb.z10)mp.MoveC(r4,r3,abb.v50,abb.fine)# Print out RAPID module of motion program for debuggingprint(mp.get_program_rapid())# Execute the motion program on the robot# Change base_url to the robot IP addressclient=abb.MotionProgramExecClient(base_url="http://127.0.0.1:80")log_results=client.execute_motion_program(mp)# log_results.data is a numpy arrayimportmatplotlib.pyplotaspltfig,ax1=plt.subplots()lns1=ax1.plot(log_results.data[:,0],log_results.data[:,2:])ax1.set_xlabel("Time (s)")ax1.set_ylabel("Joint angle (deg)")ax2=ax1.twinx()lns2=ax2.plot(log_results.data[:,0],log_results.data[:,1],'-k')ax2.set_ylabel("Command number")ax2.set_yticks(range(-1,int(max(log_results.data[:,1]))+1))ax1.legend(lns1+lns2,log_results.column_headers[2:]+["cmdnum"])ax1.set_title("Joint motion")plt.show()Multi-Move Robot ExampleTwo robots can be controlled using ABB Multi-Move. Seerobot_multimove_setup_manual.mdfor setup instructions.They must have exactly the same number of motion commands. The commands
are passed with the\IDparameter corresponding to the command number.SyncMoveOnis activated
to cause the robots to move in sync. Theexecute_multimove_motion_program()function
ofMotionProgramExecClientis used to send multi-move programs to the robot.importabb_motion_program_execasabb# Fill motion program for T_ROB1t1=abb.robtarget([575,-200,1280],[0,-.707,0,.707],abb.confdata(0,0,-1,1),[0]*6)t2=abb.robtarget([575,200,1480],[0,-.707,0,.707],abb.confdata(-1,-1,0,1),[0]*6)t3=abb.robtarget([575,0,1280],[0,-.707,0,.707],abb.confdata(-1,-1,0,1),[0]*6)my_tool=abb.tooldata(True,abb.pose([0,0,0.1],[1,0,0,0]),abb.loaddata(0.001,[0,0,0.001],[1,0,0,0],0,0,0))mp=abb.MotionProgram(tool=my_tool)mp.SyncMoveOn()mp.MoveAbsJ(abb.jointtarget([5,-20,30,27,-11,-27],[0]*6),abb.v1000,abb.fine)mp.MoveL(t1,abb.v1000,abb.fine)mp.MoveJ(t2,abb.v5000,abb.fine)mp.MoveL(t3,abb.v500,abb.fine)mp.WaitTime(1)mp.MoveL(t1,abb.v5000,abb.z50)mp.MoveJ(t2,abb.v500,abb.z200)mp.MoveL(t3,abb.v5000,abb.fine)# Fill motion program for T_ROB2. Both programs must have# same number of commandst1_2=abb.robtarget([250,-200,1280],[.707,0,.707,0],abb.confdata(-1,-1,0,1),[0]*6)t2_2=abb.robtarget([250,200,1480],[.707,0,.707,0],abb.confdata(0,0,-1,1),[0]*6)t3_2=abb.robtarget([250,0,1280],[.707,0,.707,0],abb.confdata(0,0,0,1),[0]*6)my_tool2=abb.tooldata(True,abb.pose([0,0,0.5],[1,0,0,0]),abb.loaddata(0.1,[0,0,0.1],[1,0,0,0],0,0,0))mp2=abb.MotionProgram(tool=my_tool2)mp2.SyncMoveOn()mp2.MoveAbsJ(abb.jointtarget([1,1,40,2,-40,-2],[0]*6),abb.v1000,abb.fine)mp2.MoveJ(t1_2,abb.v1000,abb.fine)mp2.MoveL(t2_2,abb.v5000,abb.fine)mp2.MoveL(t3_2,abb.v500,abb.fine)mp2.WaitTime(1)mp2.MoveL(t1_2,abb.v5000,abb.z50)mp2.MoveL(t2_2,abb.v500,abb.z200)mp2.MoveL(t3_2,abb.v5000,abb.fine)# Execute the motion program on the robot# Change base_url to the robot IP addressclient=abb.MotionProgramExecClient(base_url="http://127.0.0.1:80")# Execute both motion programs simultaneouslylog_results=client.execute_multimove_motion_program([mp,mp2])# log_results.data is a numpy arrayimportmatplotlib.pyplotaspltfig,ax1=plt.subplots()lns1=ax1.plot(log_results.data[:,0],log_results.data[:,2:8])ax1.set_xlabel("Time (s)")ax1.set_ylabel("Joint angle (deg)")ax2=ax1.twinx()lns2=ax2.plot(log_results.data[:,0],log_results.data[:,1],'-k')ax2.set_ylabel("Command number")ax2.set_yticks(range(-1,int(max(log_results.data[:,1]))+1))ax1.legend(lns1+lns2,log_results.column_headers[2:8]+["cmdnum"])ax1.set_title("Robot 1 joint motion")fig,ax1=plt.subplots()lns1=ax1.plot(log_results.data[:,0],log_results.data[:,8:])ax1.set_xlabel("Time (s)")ax1.set_ylabel("Joint angle (deg)")ax2=ax1.twinx()lns2=ax2.plot(log_results.data[:,0],log_results.data[:,1],'-k')ax2.set_ylabel("Command number")ax2.set_yticks(range(-1,int(max(log_results.data[:,1]))+1))ax1.legend(lns1+lns2,log_results.column_headers[8:]+["cmdnum"])ax1.set_title("Robot 2 joint motion")plt.show()Multi-Move example using relative work object:# Multi-Move example using relative robot end effector posesimportabb_motion_program_execasabb# Fill motion program for T_ROB1# Hold constant relative position for this examplet1=abb.robtarget([0,0,-200],[1,0,0,0],abb.confdata(0,0,1,1),[0]*6)t2=t1t3=t1my_tool=abb.tooldata(True,abb.pose([0,0,0],[1,0,0,0]),abb.loaddata(0.001,[0,0,0.001],[1,0,0,0],0,0,0))my_wobj=abb.wobjdata(False,False,"ROB_2",abb.pose([0,0,0],[1,0,0,0]),abb.pose([0,0,0],[0,0,1,0]))mp=abb.MotionProgram(tool=my_tool,wobj=my_wobj)mp.SyncMoveOn()mp.MoveAbsJ(abb.jointtarget([5,-20,30,27,-11,172],[0]*6),abb.v1000,abb.fine)mp.WaitTime(0.1)mp.MoveJ(t1,abb.v1000,abb.fine)mp.MoveJ(t1,abb.v1000,abb.fine)mp.MoveL(t1,abb.v1000,abb.fine)# Fill motion program for T_ROB2. Both programs must have# same number of commandst1_2=abb.robtarget([250,-200,1280],[.707,0,.707,0],abb.confdata(-1,-1,0,1),[0]*6)t2_2=abb.robtarget([250,200,1480],[.707,0,.707,0],abb.confdata(0,0,-1,1),[0]*6)t3_2=abb.robtarget([250,0,1280],[.707,0,.707,0],abb.confdata(0,0,0,1),[0]*6)my_tool2=abb.tooldata(True,abb.pose([0,0,0.5],[1,0,0,0]),abb.loaddata(0.1,[0,0,0.1],[1,0,0,0],0,0,0))mp2=abb.MotionProgram(tool=my_tool2)mp2.SyncMoveOn()mp2.MoveAbsJ(abb.jointtarget([1,1,40,2,-40,-2],[0]*6),abb.v1000,abb.fine)mp2.WaitTime(0.1)mp2.MoveL(t1_2,abb.v1000,abb.fine)mp2.MoveL(t2_2,abb.v5000,abb.fine)mp2.MoveL(t3_2,abb.v500,abb.fine)# Execute the motion program on the robot# Change base_url to the robot IP addressclient=abb.MotionProgramExecClient(base_url="http://127.0.0.1:80")# Execute both motion programs simultaneouslylog_results=client.execute_multimove_motion_program([mp,mp2])# log_results.data is a numpy arrayimportmatplotlib.pyplotaspltfig,ax1=plt.subplots()lns1=ax1.plot(log_results.data[:,0],log_results.data[:,2:8])ax1.set_xlabel("Time (s)")ax1.set_ylabel("Joint angle (deg)")ax2=ax1.twinx()lns2=ax2.plot(log_results.data[:,0],log_results.data[:,1],'-k')ax2.set_ylabel("Command number")ax2.set_yticks(range(-1,int(max(log_results.data[:,1]))+1))ax1.legend(lns1+lns2,log_results.column_headers[2:8]+["cmdnum"])ax1.set_title("Robot 1 joint motion")fig,ax1=plt.subplots()lns1=ax1.plot(log_results.data[:,0],log_results.data[:,8:])ax1.set_xlabel("Time (s)")ax1.set_ylabel("Joint angle (deg)")ax2=ax1.twinx()lns2=ax2.plot(log_results.data[:,0],log_results.data[:,1],'-k')ax2.set_ylabel("Command number")ax2.set_yticks(range(-1,int(max(log_results.data[:,1]))+1))ax1.legend(lns1+lns2,log_results.column_headers[8:]+["cmdnum"])ax1.set_title("Robot 2 joint motion")plt.show()Robot Raconteur ServiceA Robot Raconteur service is available to allow a client to execute multi-move programs. The service
uses a standards track service definitionexperimental.robotics.motion_programthat will provide interoperability
between multiple robot types. Due to the differences in the robot commands between controller implementations there
may be slight differences in the commands between robots, but in general the commands are very similar.When installing the module, include therobotraconteuroption to get the required dependencies:python-mpipinstallabb-motion-program-exec[robotraconteur]Start the service, specifying a robot info file:abb-motion-program-exec-robotraconteur --mp-robot-info-file=config/abb_multimove_motion_program_robot_default_config.ymlOptionally start using a module if the entrypoint does not work:python -m abb-motion-program-exec.robotraconteur --mp-robot-info-file=config/abb_multimove_motion_program_robot_default_config.ymlThe following options are supported:--mp-robot-info-file=- The info file that specifies information about the robot--mp-robot-base-url=- The connection URL for Robot Web Services on the robot. Defaults tohttp://127.0.0.1:80for use with Robot Studio virtual controllers. Set127.0.0.1to the WAN IP address of the robot.--mp-robot-username=- The robot controller username. Defaults to "Default User"--mp-robot-password=- The robot controller password. Defaults to "robotics"Examples for a single robot and multi-move robots are in theexamples/robotraconteurdirectory. The motion
programs make heavy use ofvarvaluetypes to allow for flexibility in the motion program contents.
The Python typeRR.VarValueis used to represent thevarvaluetype. See the Robot Raconteur Python documentation
for more inforamtion on howRR.VarValueworks and why it is necessary.LicenseApache 2.0 License, Copyright 2022 Wason Technology, LLC, Rensselaer Polytechnic InstituteAcknowledgmentThis 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. |
abbr | No description available on PyPI. |
abbr-cli | abbr-cliA command-line tool to look up abbreviations for terms (and the reverse). The abbreviations (or the terms in reverse
lookup) are extracted fromabbreviations.com.$abbrconfiguration(5/5)cfg(4/5)config(-/5)conf(-/5)cnf
$abbr--reversealloc(3/5)Allocation(-/5)AllocateTable of contentInstallationExploring the argumentsA little better than abbreviations.comInstallationPython version 3.6 or greater is required.Install viapipcommand:$pipinstallabbr-cliExploring the arguments$abbrconfiguration(5/5)cfg(4/5)config(-/5)conf(-/5)cnf
$abbrconfiguration--with-category(5/5)cfg~Miscellaneous,Computing(4/5)config~Governmental(-/5)conf~Computing(-/5)cnf~Computing
$abbrconfiguration--only-words
cfg
config
conf
cnf
$abbrconfiguration--min-stars4(5/5)cfg(4/5)config
$abbrconfiguration--limit1(5/5)cfgA little better than abbreviations.comNo duplicates.Abbreviations with a single charater are removed.A single abbreviation (or term in case of--reveriseflag) with multiple cateogries (and sometimes subcategories)
are merged in a single line. Subcategories are removed to avoid clutter. The rating will be the average rating.# instead of getting$abbrcommand--with-category(5/5)cmd~Governmental/NASA(4/5)cmd~Governmental/Military(4/5)cmd~Computing/DOSCommands(5/5)cmd~Computing(-/5)cmd~Miscellaneous/Aircraft
...# you will get$abbrcommand--with-category(4/5)cmd~Governmental,Computing,Miscellaneous
...Abbreviations are normalized to lowercase, while terms are normatlized to title case.# instead of getting$abbraddress(4/5)ADD(3/5)addr
...# you will get$abbraddress(4/5)add(3/5)addr
... |
abbreader | No description available on PyPI. |
abbrev | 🐜abbrev: Expand abbreviations 🐜Expand aSequenceorMappingof string abbreviations.Handy when the user has a choice of commands with long names.Example 1: Use a list of choicesimport abbrev
a = ['one', 'two', 'three']
assert abbrev(a, 'one') == 'one'
assert abbrev(a, 'o') == 'one'
assert abbrev(a, 'tw') == 'two'
abbrev(a, 'four') # Raises a KeyError: no such key
abbrev(a, 't') # Raises a KeyError: ambiguous key ('two' or 'three'?)Example 2: Use a dictionary of choicesimport abbrev
d = {'one': 100, 'two': 200, 'three': 300}
assert abbrev(d, 'one') == 100
assert abbrev(d, 'o') == 100
assert abbrev(d, 'tw') == 200Example 3: Make an abbreviator to re-useimport abbrev
d = {'one': 100, 'two': 200, 'three': 300}
abbreviator = abbrev(d)
assert abbreviator('one') == my_abbrevs('o') == 100
assert abbreviator('tw') == 200Example 4: Get all matches, whenmulti=Trueimport abbrev
a = ['one', 'two, 'three'}
multi = abbrev(a, multi=True) # Make an abbreviator
assert multi('t') == abbrev(d, 't', multi=True) == ('two', three')
assert multi('o') == abbrev(d, 'o', multi=True) == ('one', )
multi('four') # Still raises a key errorExample 5: Get only the first result, whenunique=Falseimport abbrev
d = {'one': 100, 'two': 200, 'three': 300}
assert abbrev(d, 't', unique=False) == (200, 300)API Documentation |
abbreviate | Abbreviate==========This filter attempts to automatically and intelligently abbreviate strings.This library contains a dictionary of known abbreviations. Some words havemultiple abbreviations, e.g. Thursday could be abbreviated as any of Thurs,Thur, Thr, Th, or T depending on context. With no other information, each wordhas a "preferred abbreviation" (Thr), however options can push things one wayor another. For words without known abbreviations, a series of heuristics areapplied to shorten them as needed.The basic `abbreviate` method will only apply preferred abbreviations andno heuristics. For more advanced applications, the library can be given atarget length and effort, and will attempt to generate the best stringpossible. Length can be supplied either as a simple character count, or with acustom length function. The latter is useful in many graphics applicationswithout monospaced fonts or constant kerning. By default, abbreviate will notshorten any exisiting abbreviations (e.g. Thur -> Th), assuming that anyexplicit abbreviation was passed as such for a reason.Issues, updates, pull requests, etc should be directed`to github <https://github.com/ppannuto/python-abbreviate`__.State-----This tool was written to scratch an immediate itch and is thus quiteincomplete, but with extensibility and somewhat grander ideas in mind.Architectural thoughts, radical changes to methodology, or just greaterabbreviations are all welcome.Installation------------The easiest method is to simply use pip:::(sudo) pip install abbreviateUsage-----TODO |
abbreviate-names | abbreviate-namesUniquely abbreviate a set of names in a language-appropriate way.
The original intent was to shorten a collection of Latin species names
such that they would fit more nicely into tables and graphs, but other
applications abound!This packages provides botha programmatic API,names.abbreviate.abbreviate()anda command line tool,abbreviate-names.If installed with English or Latin options it also includes dependencies
on natural language modules which enable it to break names up at
syllable boundaries, which produces more readable results:pipinstall'abbreviate-names[Latin,English]'Example outputSpeciesAbbreviation using Latin syllables.. or by characterAgathidium laevigatumAgat.lae.A.l.Agathidium nigrinumAgat.nigrinumA.nigrin.Agathidium nigripenneAgat.nigripen.A.nigrip.Agathidium seminulumAgat.se.A.s.Agonum ericetiAgo.e.A.e.Agonum fuliginosumAgo.fu.A.f.Agonum gracileAgo.gra.A.g.Lithocharis sp.Lit.sp.L.sp.Xylocleptes bispinusXy.bis.X.b.Xylodromus concinnusXy.con.X.c.Xylodromus depressusXy.de.X.d.Xylostiba monilicornisXy.mo.X.m.Zeugophora subspinosaZeu.sub.Z.s.Observe:Several different words above are all shortened to “Xy.” or “X.” —
it's the whole abbreviation that's unique, not the individual words.The already-abbreviated “sp.” is untouched.OnlineGitHub:https://github.com/ConradHughes/abbreviate-namesPyPI:https://pypi.org/project/abbreviate-names/ChangelogAll notable changes to this project will be documented in this file.The format is based onKeep a Changelog,
and this project adheres toSemantic Versioning.[Unreleased][0.1.2] - 2020-08-31AddedInitial version by@ConradHughes, includinglibrary function,command line script,support for Latin and English. |
abbreviations | No description available on PyPI. |
abbreviations-py | abbreviations_pyabbreviations_pyis a Python package that provides a convenient way to abbreviate and normalize text. It offers functionality to clean text by replacing common abbreviations with their full forms, removing punctuations and hashtags.InstallationYou can installabbreviations_pyusingpip:pipinstallabbreviations-pyUsagefromabbreviations_py.textes.abbreviatorimportfix,update_abbreviations# Fix abbreviated textinput_text="I'll txt you when you're back, ttyl! #BonVoyage"result=fix(input_text)print(result)# Output: I will text you when you are back talk to you later# Update abbreviation mappingsnew_mappings={"ttyl":"talk to you later","txt":"text",# Add more mappings here}update_abbreviations(new_mappings)ContributingContributions are welcome! If you encounter any issues or have suggestions for improvements, please feel free to open an issue or submit a pull request.LicenseThis project is licensed under theMIT License.Created byPrajwal Khairnar |