Datasets:

Saravanan666

/

pypi-org

like 0

aactivator

No description available on PyPI.

aactools

aactoolsThis file will become your README and also the index of your documentation.InstallpipinstallaactoolsHow to useFill me in please! Don’t forget code examples:1+12

aad

Azure AD B2CSimplified Python SDK for verifying AD B2C-issued JWTsUsageimportaadtoken="..."# JWT to verifytenant="..."# B2C tenant (as in `"{tenant}.b2clogin.com/{tenant}..."`)app_id="..."# ClientID of app registered in the B2C tenantpolicy="B2C_1_..."# policy (aka user flow) nameawaitaad.authorize(token,tenant,app_id,policy)# {# "idp": "...",# "aud": "...",# ... # other JWT fields# ... # fields configured in B2C# }FastAPI dependencypipinstallaad[fastapi]fromfastapiimportFastAPIimportaadClaims=aad.claims(tenant,app_id,policy)app=FastAPI()@app.get("...")defget(claims:Claims):...DisclaimerHeavily inspired byazure-ad-verify-token, but with an async interface

aad2onnx

No description available on PyPI.

aada

Advanced Algorithms for Decision AnalysisWork in progress.

aa-datalib

Failed to fetch description. HTTP Status Code: 404

aad-aws-sso

No description available on PyPI.

aadb

No description available on PyPI.

aadbook

aadbook– access your Azure AD contacts from the command line.AboutAADBook is a fork ofGooBookfocusing on making it possible to use your Azure AD contacts from the command-line and from MUAs such as Mutt.Installation InstructionsThere is a number of ways to install Python software.Using pipUsing a source tarballUsing source directly from gitoriusFrom a distribution specific repositorypip or easy_installThis is the recommended way to installaadbookfor most users that don’t have it available in their distribution. When installing this way you will not need to download anything manually.Install like this:pip install aadbookSource installationDownload the source tarball, uncompress it, then run the install command:tar -xzvf aadbook-*.tar.gz cd aadbook-* sudo python ./setup.py installConfigureFor most users it will be enough to to run:aadbook authenticateand follow the instructions.To get access too more settings you can create a configuration file:aadbook config-template > ~/.aadbookkrcIt will look like this:# "#" or ";" at the start of a line makes it a comment. [DEFAULT] # The following are optional, defaults are shown # This file is written by the Azure AD library, and should be kept secure, # it's like a password to your AD contacts. ;auth_db_filename: ~/.aadbook_auth.json ;cache_filename: ~/.aadbook_cache ;cache_expiry_hours: 24Proxy settingsIf you use a proxy you need to set thehttps_proxyenvironment variable.MuttIf you want to useaadbookfrom mutt.Set in your .muttrc file:set query_command="aadbook query '%s'"to query address book.UsageTo query your contacts:aadbook query QUERYThe cache is updated automatically according to the configuration but you can also force an update:aadbook reloadFor more commands see:aadbook -hand:aadbook COMMAND -hChangelog0.2.0 (2019-09-22)Adds Python3 support (and removes support for Python2)0.1.3 (2019-05-01)Updates dependencies0.1.2 (2018-11-01)Switches torequests==2.20.00.1.1 (2018-10-21)Fixes a bug where an exception thrown at startup when automatically refreshing auth tokens could make theauthenticatecommand fail, leaving the user with no option other than wiping outaadbookcaches0.1.0 (2018-10-09)Implements automatic fuzzy finding by replacing each `` `` in the search query string with.*0.0.3 (2018-10-01):Fixes a bug where internal credentials were not properly updated after tokens were updated using the refreshToken – throwing an error on the firstaadbook query …invocation0.0.2 (2018-09-16):Theauthenticatecommand now always initiates a full authentication workflow, irrespective of any cached tokenStart up time has improved thanks the the internal token now being refreshed only when expired0.0.1 (2018-09-08):Project inception

aad-client

No description available on PyPI.

aadetools

No description available on PyPI.

aad-fastapi

Protecting your FAST API web API with Azure ADThis package allows you to protect easily your Web API, using Azure AD.It has been created specifically forFAST API, delivering a newmiddlewarein the pipeline toauthenticateandauthorizeany http requests, if needed.InstallationTo install withpip:>python-mpipinstallaad_fastapiUsageOnce configured in Azure AD (see sections below), just add anauthentication middlewarewith theAadBearerBackend:fromaad_fastapiimport(AadBearerBackend,AadUser,authorize,oauth2_scheme,AzureAdSettings)# App Registration settings for protecting all the APIs.api_options=AzureAdSettings()api_options.client_id=environ.get("API_CLIENT_ID")api_options.domain=environ.get("DOMAIN")api_options.scopes=environ.get("SCOPES")# App Registration setting for authentication SWAGGER WEB UI AUTHENTICATION.web_ui_client_id=environ.get("CLIENT_ID")# Client IDweb_ui_scopes=environ.get("SCOPES")# Client ID# pre fill client idswagger_ui_init_oauth={"usePkceWithAuthorizationCodeGrant":"true","clientId":web_ui_client_id,"appName":"B-ID","scopes":web_ui_scopes,}# Create a FasAPI instanceapp=FastAPI(swagger_ui_init_oauth=swagger_ui_init_oauth)# Add the bearer middleware, protected with Api App Registrationapp.add_middleware(AuthenticationMiddleware,backend=AadBearerBackend(api_options))Once configured, you can addauthentication dependency injectionto your routers:# These routers needs an authentication for all its routes using Web App Registrationapp.include_router(engines.router,dependencies=[Depends(oauth2_scheme(options=api_options))])Or directly to your web api route:@app.get("/user")asyncdefuser(request:Request,token=Depends(oauth2_scheme(options=api_options))):returnrequest.userif you are inspecting therequest.userobject, you will find all the user's property retrieved fromAzure AD.You can specifyscopesand / orroles, usingdecorators, to be checked before accessing your web api:@app.get("/user_with_scope")@authorize("user_impersonation")asyncdefuser_with_scope(request:Request,token=Depends(oauth2_scheme(options=api_options))):# code here@app.get("/user_with_scope_and_roles")@authorize("user_impersonation","admin-role")asyncdefuser_with_scope_and_roles(request:Request,token=Depends(oauth2_scheme(options=api_options))):# code hereRole Requirements and Multiple RolesThe@authorizedecorator is capable of specifying multiple roles as a list of string, which will be checked against the user's roles. Ifallthe roles are found, the user is authorized.To require the user to haveat least oneof the specified roles, you can use therole_requirementparameter with the valueRoleRequirement.ANY:@app.get("/user_with_scope_and_roles_any")@authorize("user_impersonation",roles=["admin","superuser"],role_requirement=RoleRequirement.ANY)asyncdefuser_with_scope_and_roles_any(request:Request,token=Depends(oauth2_scheme(options=api_options))):# code hereNOTE:RoleRequirement.ALLis the default behavior and does not need to be specified.Register your application within your Azure AD tenantThere are two applications to register:First one will protect the Web API. It will only allows bearer token to access with the correct scope.Second one will allow the user to authenticate himself and get a token to access the Web API, using the correct scope.Register the Web API applicationThe Web API application does not need to allow user to authenticate. The main purpose of this application is to protect our Web API.Navigate to the Microsoft identity platform for developersApp registrationspage.SelectNew registration.In theRegister an application pagethat appears, enter your application's registration information:In theNamesection, enter an application name, for examplepy-api.UnderSupported account types, selectAccounts in this organizational directory only (Microsoft only - Single tenant).SelectRegisterto create the application.In the app's registration screen, find and note theApplication (client) ID. You use this value in your app's configuration file(s) later in your code.SelectSaveto save your changes.In the app's registration screen, select theExpose an APIblade to the left to open the page where you can declare the parameters to expose this app as an API for which client applications can obtainaccess tokensfor. The first thing that we need to do is to declare the uniqueresourceURI that the clients will be using to obtain access tokens for this API. To declare an resource URI, follow the following steps:ClickSetnext to theApplication ID URIto generate a URI that is unique for this app.For this sample, we are using the domain name and the client id as theApplication ID URI (https://{domain}.onmicrosoft.com/{clientId}) by selectingSave.All APIs have to publish a minimum of onescopefor the client's to obtain an access token successfully. To publish a scope, follow the following steps:SelectAdd a scopebutton open theAdd a scopescreen and Enter the values as indicated below:ForScope name, useuser_impersonation.SelectAdmins and usersoptions forWho can consent?KeepStateasEnabledClick on theAdd scopebutton on the bottom to save this scope.Register the Client applicationThe Client application will allow the user to authenticate, and will expose a scope to the Web Api application.Navigate to the Microsoft identity platform for developersApp registrationspage.SelectNew registration.In theRegister an application pagethat appears, enter your application's registration information:In theNamesection, enter an application name that will be displayed to users, for examplepy-web.UnderSupported account types, selectAccounts in this organizational directory only (Microsoft only - Single tenant).SelectRegisterto create the application.In the app's registration screen, find and note theApplication (client) ID. You use this value in your app's configuration file(s) later in your code.In the app's registration screen, selectAuthenticationin the menu.If you don't have a platform added, selectAdd a platformand select theWeboption.In theRedirect URIs|Suggested Redirect URIs for public clients (mobile, desktop)section, selecthttp://localhost:5000/auth/oauth2-redirectSelect againAdd a platformand select theSingle-page applicationoption.In theRedirect URIs|Suggested Redirect URIs for public clients (mobile, desktop)section, selecthttp://localhost:5000/docs/oauth2-redirectSelectSaveto save your changes.Do not activate the implicit flow, as we are using thenew Authorization Code Flow with PKCE(https://oauth.net/2/pkce/)In the app's registration screen, click on theCertificates & secretsblade in the left to open the page where we can generate secrets and upload certificates.In theClient secretssection, click onNew client secret:Type a key description (for instancesamplein our sample),Select one of the available key durations (In 1 year,In 2 years, orNever Expires) as per your security concerns.The generated key value will be displayed when you click theAddbutton. Copy the generated value for use in the steps later.You'll need this key later in your code's configuration files. This key value will not be displayed again, and is not retrievable by any other means, so make sure to noteIn the app's registration screen, click on theAPI permissionsblade in the left to open the page where we add access to the APIs that your application needs.Click theAdd a permissionbutton and then,Ensure that theMy APIstab is selected.In the list of APIs, select the APIpy-api.In theDelegated permissionssection, select theuser_impersonationin the list.Click on theAdd permissionsbutton at the bottom.Configure Known Client Applications in the Web API applicationFor a middle tier Web API to be able to call a downstream Web API, the middle tier app needs to be granted the required permissions as well. However, since the middle tier cannot interact with the signed-in user, it needs to be explicitly bound to the client app in its Azure AD registration. This binding merges the permissions required by both the client and the middle tier Web API and presents it to the end user in a single consent dialog. The user then consent to this combined set of permissions.To achieve this, you need to add theApplication Idof the client app (py-webin our sample), in the Manifest of the Web API in theknownClientApplicationsproperty. Here's how:In theAzure portal, navigate to yourpy-apiapp registration, and selectExpose an APIsection.In the textbox, fill the Client ID of thepy-webapplicationSelect the authorized scopeuser_impersonationClickAdd applicationConfigure the .devcontainerOpen the project in VS Code and configure correctly the.devcontainer/devcontainer.jsonfile:TENANT_ID={GUID}# The tenant id where you've created the application registrationsSUBSCRIPTION_ID={GUID}# Your subscription idDOMAIN={domain}.onmicrosoft.com# the domain nameAUTHORITY=https://login.microsoftonline.com/{tenant_id}# Authority used to login in Azure AD# App Registration information for Web AuthenticationCLIENT_ID={GUID}# This client id is the authentication client id used by the user (from `py-web` application registration)CLIENT_SECRET={PWD}# youSCOPES=https://{domain}.onmicrosoft.com/{client_id}/user_impersonation :# Scope exposed to the `py-web` applicationAPI_URL=http://localhost:8000VAULT_NAME={Vault Name}# Optional : Key vault used to store the secretVAULT_SECRET_KEY={Vault key}# Optional : Key vault secret's key# App Registration information for Api ProtectionAPI_CLIENT_ID={GUID}# Client id for the web api protection (from `py-api` application registration)Run the applicationThe solutions provides alaunch.jsonexample (in the/.vscodefolder) that you can use to launch the demo.In VS Code, select the Run and Debug blade on the left paneSelect theAPIsub menu item and click the green arrow (or hitF5)Navigate to the urlhttp://localhost:8000/docsand test the user authentication experienceYou don't need to fill the secret textbox when trying to authenticate your user, since we are using the PKCE method

aad-fastapi-dl37

Protecting your FAST API web API with Azure ADThis package allows you to protect easily your Web API, using Azure AD.It has been created specificaly forFAST API, delivering a newmiddlewarein the pipeline toauthenticateandauthorizeany http requests, if needed.InstallationTo install withpip:/>python-mpipinstallaad_fastapiUsageOnce configured in Azure AD (see sections below), just add anauthentication middlewarewith theAadBearerBackend:fromaad_fastapiimport(AadBearerBackend,AadUser,authorize,oauth2_scheme,AzureAdSettings)# App Registration settings for protecting all the APIs.api_options=AzureAdSettings()api_options.client_id=environ.get("API_CLIENT_ID")api_options.domain=environ.get("DOMAIN")api_options.scopes=environ.get("SCOPES")# App Registration setting for authentication SWAGGER WEB UI AUTHENTICATION.web_ui_client_id=environ.get("CLIENT_ID")# Client IDweb_ui_scopes=environ.get("SCOPES")# Client ID# pre fill client idswagger_ui_init_oauth={"usePkceWithAuthorizationCodeGrant":"true","clientId":web_ui_client_id,"appName":"B-ID","scopes":web_ui_scopes,}# Create a FasAPI instanceapp=FastAPI(swagger_ui_init_oauth=swagger_ui_init_oauth)# Add the bearer middleware, protected with Api App Registrationapp.add_middleware(AuthenticationMiddleware,backend=AadBearerBackend(api_options))Once configured, you can addauthentication dependency injectionto your routers:# These routers needs an authentication for all its routes using Web App Registrationapp.include_router(engines.router,dependencies=[Depends(oauth2_scheme(options=api_options))])Or directly to your web api route:@app.get("/user")asyncdefuser(request:Request,token=Depends(oauth2_scheme(options=api_options))):returnrequest.userif you are inspecting therequest.userobject, you will find all the user's property retrieved fromAzure AD.You can specifyscopesand / orroles, usingdecorators, to be checked before accessing your web api:@app.get("/user_with_scope")@authorize("user_impersonation")asyncdefuser_with_scope(request:Request,token=Depends(oauth2_scheme(options=api_options))):# code here@app.get("/user_with_scope_and_roles")@authorize("user_impersonation","admin-role")asyncdefuser_with_scope_and_roles(request:Request,token=Depends(oauth2_scheme(options=api_options))):# code hereRegister your application within your Azure AD tenantThere are two applications to register:First one will protect the Web API. It will only allows bearer token to access with the correct scope.Second one will allow the user to authenticate himself and get a token to access the Web API, using the correct scope.Register the Web API applicationThe Web API application does not need to allow user to authenticate. The main purpose of this application is to protect our Web API.Navigate to the Microsoft identity platform for developersApp registrationspage.SelectNew registration.In theRegister an application pagethat appears, enter your application's registration information:In theNamesection, enter an application name, for examplepy-api.UnderSupported account types, selectAccounts in this organizational directory only (Microsoft only - Single tenant).SelectRegisterto create the application.In the app's registration screen, find and note theApplication (client) ID. You use this value in your app's configuration file(s) later in your code.SelectSaveto save your changes.In the app's registration screen, select theExpose an APIblade to the left to open the page where you can declare the parameters to expose this app as an API for which client applications can obtainaccess tokensfor. The first thing that we need to do is to declare the uniqueresourceURI that the clients will be using to obtain access tokens for this API. To declare an resource URI, follow the following steps:ClickSetnext to theApplication ID URIto generate a URI that is unique for this app.For this sample, we are using the domain name and the client id as theApplication ID URI (https://{domain}.onmicrosoft.com/{clientId}) by selectingSave.All APIs have to publish a minimum of onescopefor the client's to obtain an access token successfully. To publish a scope, follow the following steps:SelectAdd a scopebutton open theAdd a scopescreen and Enter the values as indicated below:ForScope name, useuser_impersonation.SelectAdmins and usersoptions forWho can consent?KeepStateasEnabledClick on theAdd scopebutton on the bottom to save this scope.Register the Client applicationThe Client application will allow the user to authenticate, and will expose a scope to the Web Api application.Navigate to the Microsoft identity platform for developersApp registrationspage.SelectNew registration.In theRegister an application pagethat appears, enter your application's registration information:In theNamesection, enter an application name that will be displayed to users, for examplepy-web.UnderSupported account types, selectAccounts in this organizational directory only (Microsoft only - Single tenant).SelectRegisterto create the application.In the app's registration screen, find and note theApplication (client) ID. You use this value in your app's configuration file(s) later in your code.In the app's registration screen, selectAuthenticationin the menu.If you don't have a platform added, selectAdd a platformand select theWeboption.In theRedirect URIs|Suggested Redirect URIs for public clients (mobile, desktop)section, selecthttp://localhost:5000/auth/oauth2-redirectSelect againAdd a platformand select theSingle-page applicationoption.In theRedirect URIs|Suggested Redirect URIs for public clients (mobile, desktop)section, selecthttp://localhost:5000/docs/oauth2-redirectSelectSaveto save your changes.Do not activate the implicit flow, as we are using thenew Authorization Code Flow with PKCE(https://oauth.net/2/pkce/)In the app's registration screen, click on theCertificates & secretsblade in the left to open the page where we can generate secrets and upload certificates.In theClient secretssection, click onNew client secret:Type a key description (for instancesamplein our sample),Select one of the available key durations (In 1 year,In 2 years, orNever Expires) as per your security concerns.The generated key value will be displayed when you click theAddbutton. Copy the generated value for use in the steps later.You'll need this key later in your code's configuration files. This key value will not be displayed again, and is not retrievable by any other means, so make sure to noteIn the app's registration screen, click on theAPI permissionsblade in the left to open the page where we add access to the APIs that your application needs.Click theAdd a permissionbutton and then,Ensure that theMy APIstab is selected.In the list of APIs, select the APIpy-api.In theDelegated permissionssection, select theuser_impersonationin the list.Click on theAdd permissionsbutton at the bottom.Configure Known Client Applications in the Web API applicationFor a middle tier Web API to be able to call a downstream Web API, the middle tier app needs to be granted the required permissions as well. However, since the middle tier cannot interact with the signed-in user, it needs to be explicitly bound to the client app in its Azure AD registration. This binding merges the permissions required by both the client and the middle tier Web API and presents it to the end user in a single consent dialog. The user then consent to this combined set of permissions.To achieve this, you need to add theApplication Idof the client app (py-webin our sample), in the Manifest of the Web API in theknownClientApplicationsproperty. Here's how:In theAzure portal, navigate to yourpy-apiapp registration, and selectExpose an APIsection.In the textbox, fill the Client ID of thepy-webapplicationSelect the authorized scopeuser_impersonationClickAdd applicationConfigure the .devcontainerOpen the project in VS Code and configure correctly the.devcontainer/devcontainer.jsonfile:TENANT_ID={GUID}# The tenant id where you've created the application registrationsSUBSCRIPTION_ID={GUID}# Your subscription idDOMAIN={domain}.onmicrosoft.com# the domain nameAUTHORITY=https://login.microsoftonline.com/{tenant_id}# Authority used to login in Azure AD# App Registration information for Web AuthenticationCLIENT_ID={GUID}# This client id is the authentication client id used by the user (from `py-web` application registration)CLIENT_SECRET={PWD}# youSCOPES=https://{domain}.onmicrosoft.com/{client_id}/user_impersonation :# Scope exposed to the `py-web` applicationAPI_URL=http://localhost:8000VAULT_NAME={Vault Name}# Optional : Key vault used to store the secretVAULT_SECRET_KEY={Vault key}# Optional : Key vault secret's key# App Registration information for Api ProtectionAPI_CLIENT_ID={GUID}# Client id for the web api protection (from `py-api` application registration)Run the applicationThe solutions provides alaunch.jsonexample (in the/.vscodefolder) that you can use to launch the demo.In VS Code, select the Run and Debug blade on the left paneSelect theAPIsub menu item and click the green arrow (or hitF5)Navigate to the urlhttp://localhost:8000/docsand test the user authentication experienceYou don't need to fill the secret textbox when trying to authenticate your user, since we are using the PKCE method

aad-fastapi-dlg

Protecting your FAST API web API with Azure ADThis package allows you to protect easily your Web API, using Azure AD.It has been created specificaly forFAST API, delivering a newmiddlewarein the pipeline toauthenticateandauthorizeany http requests, if needed.InstallationTo install withpip:>python-mpipinstallaad_fastapiUsageOnce configured in Azure AD (see sections below), just add anauthentication middlewarewith theAadBearerBackend:fromaad_fastapiimport(AadBearerBackend,AadUser,authorize,oauth2_scheme,AzureAdSettings)# App Registration settings for protecting all the APIs.api_options=AzureAdSettings()api_options.client_id=environ.get("API_CLIENT_ID")api_options.domain=environ.get("DOMAIN")api_options.scopes=environ.get("SCOPES")# App Registration setting for authentication SWAGGER WEB UI AUTHENTICATION.web_ui_client_id=environ.get("CLIENT_ID")# Client IDweb_ui_scopes=environ.get("SCOPES")# Client ID# pre fill client idswagger_ui_init_oauth={"usePkceWithAuthorizationCodeGrant":"true","clientId":web_ui_client_id,"appName":"B-ID","scopes":web_ui_scopes,}# Create a FasAPI instanceapp=FastAPI(swagger_ui_init_oauth=swagger_ui_init_oauth)# Add the bearer middleware, protected with Api App Registrationapp.add_middleware(AuthenticationMiddleware,backend=AadBearerBackend(api_options))Once configured, you can addauthentication dependency injectionto your routers:# These routers needs an authentication for all its routes using Web App Registrationapp.include_router(engines.router,dependencies=[Depends(oauth2_scheme(options=api_options))])Or directly to your web api route:@app.get("/user")asyncdefuser(request:Request,token=Depends(oauth2_scheme(options=api_options))):returnrequest.userif you are inspecting therequest.userobject, you will find all the user's property retrieved fromAzure AD.You can specifyscopesand / orroles, usingdecorators, to be checked before accessing your web api:@app.get("/user_with_scope")@authorize("user_impersonation")asyncdefuser_with_scope(request:Request,token=Depends(oauth2_scheme(options=api_options))):# code here@app.get("/user_with_scope_and_roles")@authorize("user_impersonation","admin-role")asyncdefuser_with_scope_and_roles(request:Request,token=Depends(oauth2_scheme(options=api_options))):# code hereRegister your application within your Azure AD tenantThere are two applications to register:First one will protect the Web API. It will only allows bearer token to access with the correct scope.Second one will allow the user to authenticate himself and get a token to access the Web API, using the correct scope.Register the Web API applicationThe Web API application does not need to allow user to authenticate. The main purpose of this application is to protect our Web API.Navigate to the Microsoft identity platform for developersApp registrationspage.SelectNew registration.In theRegister an application pagethat appears, enter your application's registration information:In theNamesection, enter an application name, for examplepy-api.UnderSupported account types, selectAccounts in this organizational directory only (Microsoft only - Single tenant).SelectRegisterto create the application.In the app's registration screen, find and note theApplication (client) ID. You use this value in your app's configuration file(s) later in your code.SelectSaveto save your changes.In the app's registration screen, select theExpose an APIblade to the left to open the page where you can declare the parameters to expose this app as an API for which client applications can obtainaccess tokensfor. The first thing that we need to do is to declare the uniqueresourceURI that the clients will be using to obtain access tokens for this API. To declare an resource URI, follow the following steps:ClickSetnext to theApplication ID URIto generate a URI that is unique for this app.For this sample, we are using the domain name and the client id as theApplication ID URI (https://{domain}.onmicrosoft.com/{clientId}) by selectingSave.All APIs have to publish a minimum of onescopefor the client's to obtain an access token successfully. To publish a scope, follow the following steps:SelectAdd a scopebutton open theAdd a scopescreen and Enter the values as indicated below:ForScope name, useuser_impersonation.SelectAdmins and usersoptions forWho can consent?KeepStateasEnabledClick on theAdd scopebutton on the bottom to save this scope.Register the Client applicationThe Client application will allow the user to authenticate, and will expose a scope to the Web Api application.Navigate to the Microsoft identity platform for developersApp registrationspage.SelectNew registration.In theRegister an application pagethat appears, enter your application's registration information:In theNamesection, enter an application name that will be displayed to users, for examplepy-web.UnderSupported account types, selectAccounts in this organizational directory only (Microsoft only - Single tenant).SelectRegisterto create the application.In the app's registration screen, find and note theApplication (client) ID. You use this value in your app's configuration file(s) later in your code.In the app's registration screen, selectAuthenticationin the menu.If you don't have a platform added, selectAdd a platformand select theWeboption.In theRedirect URIs|Suggested Redirect URIs for public clients (mobile, desktop)section, selecthttp://localhost:5000/auth/oauth2-redirectSelect againAdd a platformand select theSingle-page applicationoption.In theRedirect URIs|Suggested Redirect URIs for public clients (mobile, desktop)section, selecthttp://localhost:5000/docs/oauth2-redirectSelectSaveto save your changes.Do not activate the implicit flow, as we are using thenew Authorization Code Flow with PKCE(https://oauth.net/2/pkce/)In the app's registration screen, click on theCertificates & secretsblade in the left to open the page where we can generate secrets and upload certificates.In theClient secretssection, click onNew client secret:Type a key description (for instancesamplein our sample),Select one of the available key durations (In 1 year,In 2 years, orNever Expires) as per your security concerns.The generated key value will be displayed when you click theAddbutton. Copy the generated value for use in the steps later.You'll need this key later in your code's configuration files. This key value will not be displayed again, and is not retrievable by any other means, so make sure to noteIn the app's registration screen, click on theAPI permissionsblade in the left to open the page where we add access to the APIs that your application needs.Click theAdd a permissionbutton and then,Ensure that theMy APIstab is selected.In the list of APIs, select the APIpy-api.In theDelegated permissionssection, select theuser_impersonationin the list.Click on theAdd permissionsbutton at the bottom.Configure Known Client Applications in the Web API applicationFor a middle tier Web API to be able to call a downstream Web API, the middle tier app needs to be granted the required permissions as well. However, since the middle tier cannot interact with the signed-in user, it needs to be explicitly bound to the client app in its Azure AD registration. This binding merges the permissions required by both the client and the middle tier Web API and presents it to the end user in a single consent dialog. The user then consent to this combined set of permissions.To achieve this, you need to add theApplication Idof the client app (py-webin our sample), in the Manifest of the Web API in theknownClientApplicationsproperty. Here's how:In theAzure portal, navigate to yourpy-apiapp registration, and selectExpose an APIsection.In the textbox, fill the Client ID of thepy-webapplicationSelect the authorized scopeuser_impersonationClickAdd applicationConfigure the .devcontainerOpen the project in VS Code and configure correctly the.devcontainer/devcontainer.jsonfile:TENANT_ID={GUID}# The tenant id where you've created the application registrationsSUBSCRIPTION_ID={GUID}# Your subscription idDOMAIN={domain}.onmicrosoft.com# the domain nameAUTHORITY=https://login.microsoftonline.com/{tenant_id}# Authority used to login in Azure AD# App Registration information for Web AuthenticationCLIENT_ID={GUID}# This client id is the authentication client id used by the user (from `py-web` application registration)CLIENT_SECRET={PWD}# youSCOPES=https://{domain}.onmicrosoft.com/{client_id}/user_impersonation :# Scope exposed to the `py-web` applicationAPI_URL=http://localhost:8000VAULT_NAME={Vault Name}# Optional : Key vault used to store the secretVAULT_SECRET_KEY={Vault key}# Optional : Key vault secret's key# App Registration information for Api ProtectionAPI_CLIENT_ID={GUID}# Client id for the web api protection (from `py-api` application registration)Run the applicationThe solutions provides alaunch.jsonexample (in the/.vscodefolder) that you can use to launch the demo.In VS Code, select the Run and Debug blade on the left paneSelect theAPIsub menu item and click the green arrow (or hitF5)Navigate to the urlhttp://localhost:8000/docsand test the user authentication experienceYou don't need to fill the secret textbox when trying to authenticate your user, since we are using the PKCE method

aad-fastapi-dorlugasigal

Protecting your FAST API web API with Azure ADThis package allows you to protect easily your Web API, using Azure AD.It has been created specificaly forFAST API, delivering a newmiddlewarein the pipeline toauthenticateandauthorizeany http requests, if needed.InstallationTo install withpip:/>python-mpipinstallaad_fastapiUsageOnce configured in Azure AD (see sections below), just add anauthentication middlewarewith theAadBearerBackend:fromaad_fastapiimport(AadBearerBackend,AadUser,authorize,oauth2_scheme,AzureAdSettings)# App Registration settings for protecting all the APIs.api_options=AzureAdSettings()api_options.client_id=environ.get("API_CLIENT_ID")api_options.domain=environ.get("DOMAIN")api_options.scopes=environ.get("SCOPES")# App Registration setting for authentication SWAGGER WEB UI AUTHENTICATION.web_ui_client_id=environ.get("CLIENT_ID")# Client IDweb_ui_scopes=environ.get("SCOPES")# Client ID# pre fill client idswagger_ui_init_oauth={"usePkceWithAuthorizationCodeGrant":"true","clientId":web_ui_client_id,"appName":"B-ID","scopes":web_ui_scopes,}# Create a FasAPI instanceapp=FastAPI(swagger_ui_init_oauth=swagger_ui_init_oauth)# Add the bearer middleware, protected with Api App Registrationapp.add_middleware(AuthenticationMiddleware,backend=AadBearerBackend(api_options))Once configured, you can addauthentication dependency injectionto your routers:# These routers needs an authentication for all its routes using Web App Registrationapp.include_router(engines.router,dependencies=[Depends(oauth2_scheme(options=api_options))])Or directly to your web api route:@app.get("/user")asyncdefuser(request:Request,token=Depends(oauth2_scheme(options=api_options))):returnrequest.userif you are inspecting therequest.userobject, you will find all the user's property retrieved fromAzure AD.You can specifyscopesand / orroles, usingdecorators, to be checked before accessing your web api:@app.get("/user_with_scope")@authorize("user_impersonation")asyncdefuser_with_scope(request:Request,token=Depends(oauth2_scheme(options=api_options))):# code here@app.get("/user_with_scope_and_roles")@authorize("user_impersonation","admin-role")asyncdefuser_with_scope_and_roles(request:Request,token=Depends(oauth2_scheme(options=api_options))):# code hereRegister your application within your Azure AD tenantThere are two applications to register:First one will protect the Web API. It will only allows bearer token to access with the correct scope.Second one will allow the user to authenticate himself and get a token to access the Web API, using the correct scope.Register the Web API applicationThe Web API application does not need to allow user to authenticate. The main purpose of this application is to protect our Web API.Navigate to the Microsoft identity platform for developersApp registrationspage.SelectNew registration.In theRegister an application pagethat appears, enter your application's registration information:In theNamesection, enter an application name, for examplepy-api.UnderSupported account types, selectAccounts in this organizational directory only (Microsoft only - Single tenant).SelectRegisterto create the application.In the app's registration screen, find and note theApplication (client) ID. You use this value in your app's configuration file(s) later in your code.SelectSaveto save your changes.In the app's registration screen, select theExpose an APIblade to the left to open the page where you can declare the parameters to expose this app as an API for which client applications can obtainaccess tokensfor. The first thing that we need to do is to declare the uniqueresourceURI that the clients will be using to obtain access tokens for this API. To declare an resource URI, follow the following steps:ClickSetnext to theApplication ID URIto generate a URI that is unique for this app.For this sample, we are using the domain name and the client id as theApplication ID URI (https://{domain}.onmicrosoft.com/{clientId}) by selectingSave.All APIs have to publish a minimum of onescopefor the client's to obtain an access token successfully. To publish a scope, follow the following steps:SelectAdd a scopebutton open theAdd a scopescreen and Enter the values as indicated below:ForScope name, useuser_impersonation.SelectAdmins and usersoptions forWho can consent?KeepStateasEnabledClick on theAdd scopebutton on the bottom to save this scope.Register the Client applicationThe Client application will allow the user to authenticate, and will expose a scope to the Web Api application.Navigate to the Microsoft identity platform for developersApp registrationspage.SelectNew registration.In theRegister an application pagethat appears, enter your application's registration information:In theNamesection, enter an application name that will be displayed to users, for examplepy-web.UnderSupported account types, selectAccounts in this organizational directory only (Microsoft only - Single tenant).SelectRegisterto create the application.In the app's registration screen, find and note theApplication (client) ID. You use this value in your app's configuration file(s) later in your code.In the app's registration screen, selectAuthenticationin the menu.If you don't have a platform added, selectAdd a platformand select theWeboption.In theRedirect URIs|Suggested Redirect URIs for public clients (mobile, desktop)section, selecthttp://localhost:5000/auth/oauth2-redirectSelect againAdd a platformand select theSingle-page applicationoption.In theRedirect URIs|Suggested Redirect URIs for public clients (mobile, desktop)section, selecthttp://localhost:5000/docs/oauth2-redirectSelectSaveto save your changes.Do not activate the implicit flow, as we are using thenew Authorization Code Flow with PKCE(https://oauth.net/2/pkce/)In the app's registration screen, click on theCertificates & secretsblade in the left to open the page where we can generate secrets and upload certificates.In theClient secretssection, click onNew client secret:Type a key description (for instancesamplein our sample),Select one of the available key durations (In 1 year,In 2 years, orNever Expires) as per your security concerns.The generated key value will be displayed when you click theAddbutton. Copy the generated value for use in the steps later.You'll need this key later in your code's configuration files. This key value will not be displayed again, and is not retrievable by any other means, so make sure to noteIn the app's registration screen, click on theAPI permissionsblade in the left to open the page where we add access to the APIs that your application needs.Click theAdd a permissionbutton and then,Ensure that theMy APIstab is selected.In the list of APIs, select the APIpy-api.In theDelegated permissionssection, select theuser_impersonationin the list.Click on theAdd permissionsbutton at the bottom.Configure Known Client Applications in the Web API applicationFor a middle tier Web API to be able to call a downstream Web API, the middle tier app needs to be granted the required permissions as well. However, since the middle tier cannot interact with the signed-in user, it needs to be explicitly bound to the client app in its Azure AD registration. This binding merges the permissions required by both the client and the middle tier Web API and presents it to the end user in a single consent dialog. The user then consent to this combined set of permissions.To achieve this, you need to add theApplication Idof the client app (py-webin our sample), in the Manifest of the Web API in theknownClientApplicationsproperty. Here's how:In theAzure portal, navigate to yourpy-apiapp registration, and selectExpose an APIsection.In the textbox, fill the Client ID of thepy-webapplicationSelect the authorized scopeuser_impersonationClickAdd applicationConfigure the .devcontainerOpen the project in VS Code and configure correctly the.devcontainer/devcontainer.jsonfile:TENANT_ID={GUID}# The tenant id where you've created the application registrationsSUBSCRIPTION_ID={GUID}# Your subscription idDOMAIN={domain}.onmicrosoft.com# the domain nameAUTHORITY=https://login.microsoftonline.com/{tenant_id}# Authority used to login in Azure AD# App Registration information for Web AuthenticationCLIENT_ID={GUID}# This client id is the authentication client id used by the user (from `py-web` application registration)CLIENT_SECRET={PWD}# youSCOPES=https://{domain}.onmicrosoft.com/{client_id}/user_impersonation :# Scope exposed to the `py-web` applicationAPI_URL=http://localhost:8000VAULT_NAME={Vault Name}# Optional : Key vault used to store the secretVAULT_SECRET_KEY={Vault key}# Optional : Key vault secret's key# App Registration information for Api ProtectionAPI_CLIENT_ID={GUID}# Client id for the web api protection (from `py-api` application registration)Run the applicationThe solutions provides alaunch.jsonexample (in the/.vscodefolder) that you can use to launch the demo.In VS Code, select the Run and Debug blade on the left paneSelect theAPIsub menu item and click the green arrow (or hitF5)Navigate to the urlhttp://localhost:8000/docsand test the user authentication experienceYou don't need to fill the secret textbox when trying to authenticate your user, since we are using the PKCE method

aadhaar

No description available on PyPI.

aadhaar-detection

A library for detecting Aadhaar cards in images.

aadhaar-py

aadhaar-py 🐍This library helps you extract the embedded information 💾 in Aadhaar Secure QR CodeInspired from 😇I would like to thank the authors ofpyaadhaar. It wouldn't be possible to move into the right direction without this library.Demo ✔️Secure Aadhaar QR DecoderEnough talk, show me how it works! ✨>>>fromaadhaar.secure_qrimportextract_data>>>received_qr_code_data=12345678>>>extracted_data=extract_data(received_qr_code_data)Theextract_datafunction returns an instance ofExtractedSecureQRDatawhich has the definition of:@dataclass(frozen=True)classExtractedSecureQRData:text_data:ExtractedTextDataimage:Image.Imagecontact_info:ContactDataText Data 📝:>>>extracted_data.text_dataExtractedTextData(reference_id=ReferenceId(last_four_aadhaar_digits='8908',timestamp=datetime.datetime(2019,3,5,15,1,37,123000)),name='Penumarthi Venkat',date_of_birth=datetime.date(1987,5,7),gender=<Gender.MALE:'Male'>,address=Address(care_of='S/O: Pattabhi Rama Rao',district='East Godavari',landmark='Near Siva Temple',house='4-83',location='Sctor-2',pin_code='533016',post_office='Aratlakatta',state='Andhra Pradesh',street='Main Road',sub_district='Karapa',vtc='Aratlakatta'))The Embedded Image 🌆:>>>extracted_data.image<PIL.JpegImagePlugin.JpegImageFileimagemode=RGBsize=60x60at0x1029CA460>The Contact Information 📧:>>>extracted_data.contact_infoContactData(email=Email(hex_string=None,fourth_aadhaar_digit='8'),mobile=Mobile(hex_string='1f31f19afc2bacbd8afb84526ae4da184a2727e8c2b1b6b9a81e4dc6b74d692a',fourth_aadhaar_digit='8'))But hey! 🙄 I want to send this data via a ReSTful API, don't you have something to serialize that ugly instance ofExtractedSecureQRData? 😩to_dictmethod to the rescue 💪>>>extracted_data.to_dict(){"text_data":{"reference_id":{"last_four_aadhaar_digits":"8908","timestamp":"2019-03-05T15:01:37.123000"},"name":"Penumarthi Venkat","date_of_birth":"1987-05-07","gender":"Male","address":{"care_of":"S/O: Pattabhi Rama Rao","district":"East Godavari","landmark":"Near Siva Temple","house":"4-83","location":"Sctor-2","pin_code":"533016","post_office":"Aratlakatta","state":"Andhra Pradesh","street":"Main Road","sub_district":"Karapa","vtc":"Aratlakatta"}},"image":"data:image/jpeg;base64,/9j/4AAQSkZblahblah","contact_info":{"email":{"hex_string":None},"mobile":{"hex_string":"1f31f19afc2bacbd8afb84526ae4da184a2727e8c2b1b6b9a81e4dc6b74d692a"}}}Run Tests 🧪python-munittestdiscovertests/--verbose

aadhar-pan-extractor

Description: This script extracts Aadhaar and extracts Pan information from the image uploaded by consumer. The result is returned as a json object.Installation This library requires Python 3.6+ to run. As well as you also need to install tesseract on your system. If you have Linux based system just run:use this line for Linux sudo apt install tesseract-ocrfor windows usedownload tesseract software'https://github.com/UB-Mannheim/tesseract/wiki'Then pytesseract.pytesseract.tesseract_cmd = r'C:\Program Files\Tesseract-OCR\tesseract'For Mac OSinstall brew/bin/bash -c "$(curl -fsSLhttps://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"#install brew in tesseractbrew install tesseract#list tesseractbrew list tesseractthis is list-->/usr/local/Cellar/tesseract/4.1.1/bin/tesseract/usr/local/Cellar/tesseract/4.1.1/bin/tesseract this line use for code pytesseract.pytesseract.tesseract_cmd = r'/usr/local/Cellar/tesseract/4.1.1/bin/tesseract'Install the package.pip install aadhar-pan-extractor Then Import the package.from aadhar_pan_extractor import Pan_Info_Extractor,Aadhar_Info_Extractor Create an instance of the extractor.this line use only for aadhar information extractor = Aadhar_Info_Extractor()this line use only for pan information extractor = Pan_Info_Extractor() Pass the image to the extractor to get the results.extractor.info_extractor('/content/pan test.jpeg') This will return a result as following:{ "Aadhar_number": "4382 5165 5729", "Address": "NAN", "DOB": "01/01/2003", "Gender": "Male", }

aadhilsiccalculator

This very simple functionChange Log0.0.1 (19/04/2020)First Release

aadict

Anaadictis a python dict sub-class that allows attribute-style access to dict items, e.g.d.foois equivalent tod['foo'].aadictalso provides a few other helpful methods, such aspickandomitmethods. Also, anaadictis more call chaining friendly (e.g. methods such asupdatereturnself) and is pickle’able.ProjectHomepage:https://github.com/metagriffin/aadictBugs:https://github.com/metagriffin/aadict/issuesTL;DRInstall:$pipinstallaadictUse:fromaadictimportaadict# attribute accessd=aadict(foo='bar',zig=87)assertd.foo==d['foo']=='bar'# helper methodsassertd.pick('foo')=={'foo':'bar'}assertd.omit('foo')=={'zig':87}# method chainingd2=aadict(x='y').update(d).omit('zig')assertd2.x=='y'andd2.foo=='bar'andd2.zigisNone# converting a dict to an aadict recursivelyd3=aadict.d2ar(dict(foo=dict(bar='zig')))assertd3.foo.bar=='zig'DetailsThe aadict module provides the following functionality:aadictAnaadictobject is basically identical to adictobject, with the exception that attributes, if not reserved for other purposes, map to the dict’s items. For example, if a dictdhas an item'foo', then a request ford.foowill return that item lookup. aadicts also have several helper methods, for exampleaadict.pick. To fetch the value of an item that has the same name as one of the helper methods you need to reference it by item lookup, i.e.d['pick']. The helper methods are:aadict.pickinstance method:Returns a new aadict, reduced to only include the specified keys. Example:d=aadict(foo='bar',zig=87,zag=['a','b'])assertd.pick('foo','zag')=={'foo':'bar','zag':['a','b']}aadict.omitinstance method:Identical to theaadict.pickmethod, but returns the complement, i.e. all of those keys that arenotspecified. Example:d=aadict(foo='bar',zig=87,zag=['a','b'])assertd.omit('foo','zag')=={'zig':87}aadict.d2arclass method:Recursively converts the supplieddictto anaadict, including all sub-list and sub-dict types. Due to being recursive, but only copying dict-types, this is effectively a hybrid of a shallow and a deep clone. Example:d=aadict.d2ar(dict(foo=dict(bar='zig')))assertd.foo.bar=='zig'Without the recursive walking, the.barattribute syntax would yield an AttributeError exception because d.foo would reference adicttype, not anaadict.aadict.d2aclass method:Converts the supplieddictto anaadict. Example:d=aadict.d2a(dict(foo='bar'))assertd.foo==d['foo']=='bar'Note that this is identical to just using the constructor, but is provided as a symmetry to theaadict.d2arclass method, e.g.:d=aadict(dict(foo='bar'))assertd.foo==d['foo']=='bar'

aadinspector

aadinspectorThis package will help to validate azure b2c jwt token.📝 Table of ContentsAboutGetting StartedAuthors🧐 AboutThis package will help to validate azure b2c jwt token.🏁 Getting StartedDependancy & prerequisitePython >=3.6 should be installed."cryptography==37.0.4""PyJWT==2.4.0""requests==2.28.1"To Start experimenting this package you need to install it.pip install aadinspector# public key code should run only once on app start. pub_handler= PublicKeyHandler("tenant_id") pub_handler.set_name_of_policy("name_of_policy") token="string" public_key= pub_handler.get_public_key(token) print(public_key) # token validation code should run for each request. jwt_validator = JWTValidator(public_key) is_valid, token = jwt_validator.validate(token) print(is_valid) print(token)✍️ AuthorsDinesh Kushwaha- Idea & Initial workSee also the list ofcontributorswho participated in this project.

aadioptimize

No description available on PyPI.

aa-discord-announcements

AA Discord AnnouncementsDiscord Announcements viaAlliance AuthWrite announcements and manage who can write announcements on your corporation or alliance Discord through Alliance Auth.AA Discord AnnouncementsInstallation⚠️ Important ⚠️Step 1: Install the AppStep 2: Update Your AA SettingsStep 3: Finalizing the InstallationStep 4: Setting up PermissionStep 5: Setting up the AppChangelogTranslation StatusContributingInstallation⚠️ Important ⚠️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)NoteYou also want to make sure that you have theDiscord serviceinstalled, configured and activated before installing this app.Step 1: Install the AppMake sure you're in the virtual environment (venv) of your Alliance Auth installation. Then install the latest version:pipinstallaa-discord-announcementsStep 2: Update Your AA SettingsConfigure your AA settings (local.py) as follows:Add"aa_discord_announcements",toINSTALLED_APPSStep 3: Finalizing the InstallationCopy static files and run migrationspythonmanage.pycollectstatic pythonmanage.pymigrateRestart your supervisor services for AAStep 4: Setting up PermissionNow you can set up permissions in Alliance Auth for your users. Addaa_discord_announcements | general | Can access this appto the states and/or groups you would like to have access.Step 5: Setting up the AppIn your admin backend you'll find a new section calledDiscord Announcements. This is where you set all your stuff up, like the webhooks you want to ping and who can ping them. It's pretty straight forward, so you shouldn't have any issues. Go nuts!ChangelogSeeCHANGELOG.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)

aa-discordnotify

Discord NotifyForward Alliance Auth notifications to users on DiscordContentsOverviewInstallationSettingsChange LogOverviewThis app automatically forwards Alliance Auth notifications to users on Discord.FeaturesAuth notifications appear instantly as DM on DiscordNotifications are colored according to their level (e.g. INFO = blue)Can be restricted to notifications for superusers only (e.g. to keep track of errors)ExampleInstallationStep 1 - Check preconditionsDiscord Notify 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)Discord Notify needsDiscord Proxyto function. Please make sure the server is up and running on your system, before continuing.Please also make sure you have the Discord service installed and setup in Alliance Auth.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-discordnotifyStep 3 - Configure Auth settingsConfigure your Auth settings (local.py) as follows:Add"discordnotify"toINSTALLED_APPSOptional: Add additional settings if you want to change any defaults. SeeSettingsfor the full list.Step 4 - Finalize App installationRestart your supervisor services for Auth (no migration required).Step 5 - Send test notificationTo test that your installation was successful you can create a test notification to yourself by navigating to the relative route/discordnotify/testin your browser. The absolute URL depends on your Auth site. Example: For an Auth site with the URLhttps://auth.example.comthe test URL would be:https://auth.example.com/discordnotify/testWhen everything was setup correctly, you will receive a test notification on Discord.Congratulations you are now ready to use Discord Notify!SettingsHere 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.NameDescriptionDefaultDISCORDNOTIFY_ENABLEDSet this to False to disable this app temporarilyTrueDISCORDNOTIFY_DISCORDPROXY_PORTPort used to communicate with Discord Proxy.50051DISCORDNOTIFY_MARK_AS_VIEWEDWhen enabled will mark all notifications as viewed that have been successfully submitted to DiscordFalseDISCORDNOTIFY_SUPERUSER_ONLYWhen enabled only superusers will be get their notifications forwarded.False

aa-discord-ping-formatter

AA Discord Ping FormatterApp for formatting pings for Discord in Alliance AuthContentsInstallationUpdatingScreenshotsConfigurationChange LogInstallationImportant: 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)Step 1 - Install appMake sure you are in the virtual environment (venv) of your Alliance Auth installation. Then install the latest version:pipinstallaa-discord-ping-formatterStep 2 - Update your AA settingsConfigure your AA settings (local.py) as follows:Add'discordpingformatter',toINSTALLED_APPSStep 3 - Finalize the installationRun migrations & copy static filespythonmanage.pycollectstatic pythonmanage.pymigrateRestart your supervisor services for AAStep 4 - Setup permissionsNow you can setup permissions in Alliance Auth for your users. Adddiscordpingformatter | aa discord ping formatter | Can access this appto the states and/or groups you would like to have access.UpdatingTo update your existing installation of AA Discord Ping Formatter first enable your virtual environment.Then run the following commands from your AA project directory (the one that containsmanage.py).pipinstall-Uaa-discord-ping-formatterpythonmanage.pycollectstaticpythonmanage.pymigrateFinally restart your AA supervisor services.ScreenshotsView in Alliance AuthDiscord Ping(Example for embedded ping (top) and non embedded ping (bottom))ConfigurationEmbed Webhook PingsYou have the option to embed your webhook pings. To do so you can enable it via:## AA Discord Ping FormatterAA_DISCORDFORMATTER_WEBHOOK_EMBED_PING=TrueAdding Ping TargetsPer default you have 2 ping targets you can select from. That's@everyoneand@here. If you need more than these 2, you can add them to yourlocal.pyand override the default behaviour that way.Open yourlocal.pyin an editor of your choice and add the following at the end.## AA Discord Ping FormatterAA_DISCORDFORMATTER_ADDITIONAL_PING_TARGETS=[{'roleId':'xxxxxxxxxxxxxxxxxx','roleName':'Member'},{# restricted to "Capital FCs" (GroupID 5) and "Super Capital FCs" (GroupID 7)'restrictedToGroup':[5,7,],'roleId':'xxxxxxxxxxxxxxxxxx','roleName':'Capital Pilots'},]To get theroleIdgo to your Discord Server Settings » Roles and right click the role you need and copy the ID. You might need to activate the Developer Mode for your Discord account in order to do so. You activate the Developmer Mode in your account settings under Appearance » Advanced » Developer Mode.Important:Both,roleIdandroleNameneed to be without the@, it will be added automatically.roleNameneeds to be spelled exactly as it is on Discord.Adding Fleet TypesPer default you have 4 fleet types you can select from. That'sRoam,Home Defense,StratOPandCTA. If you need more than these 4, you can add them to yourlocal.pyand override the default behaviour that way.Open yourlocal.pyin an editor of your choice and add the following at the end.## AA Discord Ping FormatterAA_DISCORDFORMATTER_ADDITIONAL_FLEET_TYPES=[# example for embedded webhook pings{'fleetType':'Mining','embedColor':'#4F545C'# can be empty but needs to be set. Needs to be #hex and 6 digits},# example for non embedded webhook pings'Ratting',]Both examples will work, no matter if you haveAA_DISCORDFORMATTER_WEBHOOK_EMBED_PINGenabled or not. But keep in mind, to set a custom color for your embed, it needs to be defined like in the first example. The color needs to be your standard hex color code like you define it in (for example) CSS as well. Pre-defined fleet types are by default: Roam = green, Home Defense = yellow, StratOP = orange, CTA = redAdding Ping ChannelsPer default, your ping will just be formatted for you to copy and paste. But, if your FCs are too lazy even for that, you can configure webhooks. One for each channel you might want to ping.Open yourlocal.pyin an editor of your choice and add the following at the end.## AA Discord Ping FormatterAA_DISCORDFORMATTER_ADDITIONAL_PING_WEBHOOKS=[{'discordChannelName':'Fleet Pings (#fleet-pings)','discordWebhookUrl':'https://discordapp.com/api/webhooks/xxxxxxxxxxxxxxxxxx/yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'},{'discordChannelName':'Pre Pings (#pre-pings)','discordWebhookUrl':'https://discordapp.com/api/webhooks/xxxxxxxxxxxxxxxxxx/yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'},{# restricted to "Capital FCs" (GroupID 5) and "Super Capital FCs" (GroupID 7)'restrictedToGroup':[5,7,],'discordChannelName':'Capital Pings (#capital-pings)','discordWebhookUrl':'https://discordapp.com/api/webhooks/xxxxxxxxxxxxxxxxxx/yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'}]Fleet Comms, Formup Location and DoctrineValues for Fleet Comms, Formup Location and Doctrine can be pre-defined as suggestions, so your FCs have a quick selection of the most used comms, stagings and doctrines to select from. These are not fixed values in the form, since we use a combination of input and select fields here. So FCs are absolutely free to something completely different in those 3 fields than the pre-defined suggestions.To define these 3 fields, open yourlocal.pyin an editor of your choice and add the following:Fleet Comms## AA Discord Ping FormatterAA_DISCORDFORMATTER_FLEET_COMMS=['Alliance Mumble','Coalition Mumble','Spy Account Mumble'# :-P]Fleet Staging## AA Discord Ping FormatterAA_DISCORDFORMATTER_FLEET_FORMUP_LOCATIONS=['Alliance Staging System','Coalition Staging System']Doctrine## AA Discord Ping FormatterAA_DISCORDFORMATTER_FLEET_DOCTRINES=['Battle Skiffs','Combat Nereus','Attack Corvettes']

aadishgarg

UNKNOWN

aad-jimmielin

Final Project Repo for Group 31Find our documentation on our websiteaad.fer.meNames:Matheus C. FernandesHaipeng LinBen Manning*TF: Johnathan JiangGit WorkflowCreate your own branch infeature/nameCommit changes and resolve merge conflicts bygit merge mainSubmit pull request tomainApprove and merge tomainCollaborative workflow in DeepnoteTo facilitate coding, we used a shared deepnote project to create shared commits under thegroup/*branches.Use Jupyter Notebook%%writefileto save into thecs107-FinalProjectfolder in Deepnote;Use the terminal togit commitstaged files as appropriate;Create the pull request and ask another teammate for approval.

aadoc

No description available on PyPI.

aadraw

AA DrawAntialiased graphic drawing library for Python pygame.

aa-drifters

Drifters for Alliance AuthDrifter wormhole tracker/manager plugin forAlliance Auth.FeaturesAA-Discordbot Cogs for recording the status of Jove Observatory systems and their contained Drifter holesCogs for recalling this information in a few waysPlanned FeaturesP2P Mapping using known holesPossible Pathfinder Integration/sync? To investigate usefullnessInstallationStep 1 - Django Eve UniverseDrifters is an App forAlliance Auth, Please make sure you have this installed. Drifters is not a standalone Django ApplicationDrifters needs the Appdjango-eveuniverseto function. Please make sure it is installed before continuing.Step 2 - Install apppipinstallaa-driftersStep 3 - Configure Auth settingsConfigure your Auth settings (local.py) as follows:Add'drifters'toINSTALLED_APPSAdd below lines to your settings file:## Settings for AA-Drifters# Cleanup TaskCELERYBEAT_SCHEDULE['drifters_garbage_collection']={'task':'drifters.tasks.garbage_collection','schedule':crontab(minute='*/15',hour='*'),}Step 4 - Maintain Alliance AuthRun migrationspython manage.py migrateGather your staticfilespython manage.py collectstaticRestart your projectsupervisorctl restart myauth:Step 5 - Pre-Load Django-EveUniversepython manage.py eveuniverse_load_data mapThis will load Regions, Constellations and Solar SystemsContributingMake 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.

aad-token-verify

aad-token-verifyA python utility library to verify an Azure Active Directory OAuth token. Meant for resource servers serving secured API endpoints (eg FastAPI)Installpython3-mpipinstallaad-token-verifyUsageTo use stand alone, simply import the verify payload function and call.fromaad_token_verifyimportget_verified_payloadtoken_verifier=get_verified_payload(token,tenant_id="YOUR_TENANT_ID",audience_uris=["AUDIENCE_URI"])To use with FastAPI, there's some setup to get the Swagger docs to workfromfastapiimportDepends,FastAPIfromfastapi.openapi.modelsimportOAuthFlowImplicit,OAuthFlowsfromfastapi.middleware.corsimportCORSMiddlewarefromfastapi.securityimportOAuth2fromaad_token_verifyimportget_verified_payload# TODO Update these with your Tenant ID, Audience URI, and Client ID_TENANT_ID="ISSUER_TENANT_ID"_AUDIENCE_URI="https://YOUR_AUDIENCE_URI"_AAD_CLIENT_ID="CLIENT_ID"oauth2_scheme=OAuth2(flows=OAuthFlows(implicit=OAuthFlowImplicit(authorizationUrl=f"https://login.microsoftonline.com/{_TENANT_ID}/oauth2/v2.0/authorize",scopes={f"{_AUDIENCE_URI}/.default":"Custom Audience URI scope","openid":"OpenID scope","profile":"Profile scope","email":"email scope",},)))asyncdefget_current_user(auth_header:str=Depends(oauth2_scheme),# noqa: B008):scheme,_,token=auth_header.partition(" ")returnget_verified_payload(token,tenantId=_TENANT_ID,audience_uris=[_AUDIENCE_URI],)app=FastAPI()app.add_middleware(CORSMiddleware,allow_origins=["*"],allow_credentials=True,allow_methods=["*"],allow_headers=["*"],)app.swagger_ui_init_oauth={"usePkceWithAuthorizationCodeGrant":True,"clientId":_AAD_CLIENT_ID,"scopes":[f"{_AUDIENCE_URI}.default"],}@app.get("/")asyncdefsecured_endpoint(user=Depends(get_current_user)):returnuserContributingFeel free to submit issues and pull requests!

aad-token-verify-kbr

aad-token-verifyA python utility library to verify an Azure Active Directory OAuth token. Meant for resource servers serving secured API endpoints (eg FastAPI)Installpython3-mpipinstallaad-token-verifyUsageTo use stand alone, simply import the verify payload function and call.fromaad_token_verifyimportget_verified_payloadtoken_verifier=get_verified_payload(token,tenant_id="YOUR_TENANT_ID",audience_uris=["AUDIENCE_URI"])To use with FastAPI, there's some setup to get the Swagger docs to workfromfastapiimportDepends,FastAPIfromfastapi.openapi.modelsimportOAuthFlowImplicit,OAuthFlowsfromfastapi.middleware.corsimportCORSMiddlewarefromfastapi.securityimportOAuth2fromaad_token_verifyimportget_verified_payload# TODO Update these with your Tenant ID, Audience URI, and Client ID_TENANT_ID="ISSUER_TENANT_ID"_AUDIENCE_URI="https://YOUR_AUDIENCE_URI"_AAD_CLIENT_ID="CLIENT_ID"oauth2_scheme=OAuth2(flows=OAuthFlows(implicit=OAuthFlowImplicit(authorizationUrl=f"https://login.microsoftonline.com/{_TENANT_ID}/oauth2/v2.0/authorize",scopes={f"{_AUDIENCE_URI}/.default":"Custom Audience URI scope","openid":"OpenID scope","profile":"Profile scope","email":"email scope",},)))asyncdefget_current_user(auth_header:str=Depends(oauth2_scheme),# noqa: B008):scheme,_,token=auth_header.partition(" ")returnget_verified_payload(token,tenantId=_TENANT_ID,audience_uris=[_AUDIENCE_URI],)app=FastAPI()app.add_middleware(CORSMiddleware,allow_origins=["*"],allow_credentials=True,allow_methods=["*"],allow_headers=["*"],)app.swagger_ui_init_oauth={"usePkceWithAuthorizationCodeGrant":True,"clientId":_AAD_CLIENT_ID,"scopes":[f"{_AUDIENCE_URI}.default"],}@app.get("/")asyncdefsecured_endpoint(user=Depends(get_current_user)):returnuserContributingFeel free to submit issues and pull requests!

aaei

Air Adverse Effect IndexCalculate the relative toxicity effect(s) of different trace gas compounds withGenRAinstall withpipinstallaaeiOrpipinstallaaei".[Viz]"to include visualization capabilitiesExample code:mkdirhealth_effectscdhealth_effects AEICopyExamples AEIRunvizpiv=Batch_Report_Target.csvThis tool uses the output ofGenRAtoxicological Generalized Read-across Database/tool.One or more chemicals can be statistically analyzed, these statistics can be applied to measured or simulated chemical concentrations.SeeGithubfor more details.

aa-esi-status

AA ESI StatusApp for Alliance Auth to show the current status of ESI and its end points.AA ESI StatusInstallationStep 1: Install the AppStep 2: Update Your AA SettingsStep 3: Finalizing the Installation(Optional) Public ViewsUpdatingChangelogTranslation StatusContributingInstallationNoteThis 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)AA ESI Status needs at leastAlliance Auth v3.6.1. Please make sure to meet this conditionbeforeinstalling this app, otherwise an update to Alliance Auth will be pulled in unsupervised.Step 1: Install the AppMake sure you're in the virtual environment (venv) of your Alliance Auth installation. Then install the latest version:pipinstallaa-esi-statusStep 2: Update Your AA SettingsConfigure your AA settings (local.py) as follows:Add"esistatus",toINSTALLED_APPSStep 3: Finalizing the InstallationRun migrations & copy static files.pythonmanage.pycollectstatic pythonmanage.pymigrateRestart your supervisor services for AA.(Optional) Public ViewsThis app supports AA's feature of public views, since the ESI status is not any mission-critical information. To allow users to view the time zone conversion page without the need to log in, please add"esistatus",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=["esistatus",# https://github.com/ppfeufer/aa-esi-status/]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 ESI Status, first enable your virtual environment.Then run the following commands from your AA project directory (the one that containsmanage.py).pipinstall-Uaa-esi-status pythonmanage.pycollectstatic pythonmanage.pymigrateNow restart your AA supervisor services.ChangelogSeeCHANGELOG.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)

aa-example-plugin

Example Plugin App for Alliance Auth (GitHub Version)This is an example plugin app forAlliance Auth(AA) that can be used as a starting point to develop custom plugins.(These badges are examples, you can and should replace them with your own)For the GitLab version of this example app, please have a look over here, Erik Kalkoken was so friendly to provide it »Alliance Auth Example App (GitLab Version)Example Plugin App for Alliance Auth (GitHub Version)FeaturesHow to Use ItCloning From RepoRenaming the AppClearing MigrationsWriting Unit TestsInstalling Into Your Dev AAInstalling Into Production AAContributeFeaturesThe plugin can be installed, upgraded (and removed) into an existing AA installation using PyInstaller.It has its own menu item in the sidebar.It has one view that shows a panel and some textHow to Use ItTo use this example as a basis for your own development, just fork this repo and then clone it on your dev machine.You then should rename the app, and then you can install it into your AA dev installation.Cloning From RepoFor this app, we're assuming that you have all your AA projects, your virtual environment, and your AA installation under one top folder (e.g. aa-dev).This should look something like this:aa-dev |- venv/ |- myauth/ |- aa-example-plugin |- (other AA projects ...)Then just cd into the top folder (e.g. aa-dev) and clone the repo from your fork. You can give the repo a new name right away (e.g.aa-your-app-name). You also want to create a new git repo for it. Finally, enablepre-committo enable automatic code style checking.gitclonehttps://github.com/YourName/aa-example-plugin.gitaa-your-app-namecdaa-your-app-name rm-rf.git gitinit pre-commitinstallRenaming the AppBefore installing this app into your dev AA you need to rename it to something suitable for your development project. Otherwise, you risk not being able to install additional apps that might also be called example.Here is an overview of the places that you need to edit to adopt the name.Easiest is to just find & replaceexamplewith your new app name in all files listed below.One small warning about picking names: Python is a bit particular about what special characters are allowed for names of modules and packages. To avoid any pitfalls, I would therefore recommend using only normal characters (a-z) in your app's name unless you know exactly what you're doing.LocationDescription./example/Folder name./example/static/example/Folder name./example/templates/example/Folder name./pyproject.cfgUpdate module name for version import, update package name, update title, author, etc../example/apps.pyApp name./example/__init__.pyApp name./example/auth_hooks.pyMenu hook config incl. icon and label of your app's menu item appearing in the sidebar./example/models.pyApp name./example/urls.pyApp name./example/views.pyPermission name and template path./example/templates/example/base.htmlTitle of your app to be shown in all views and as title in the browser tab./example/templates/example/index.htmlTemplate path./testauth/local.pyApp name inPACKAGEconstant./.coveragercApp name./MANIFEST.inApp name./README.mdClear content./LICENSEReplace with your own license./tox.iniApp name./.isort.cfgApp name forimport_heading_firstparty./MakefileApp name and package nameClearing MigrationsInstead of renaming your app in the migrations, it's easier to just recreate them later in the process. For this to work, you need to delete the old migration files in yourmigrationsfolder.rmyour-app-name/migrations/0001_initial.py rm-rfyour-app-name/migrations/_pycacheWriting Unit TestsWrite your unit tests inyour-app-name/tests/and make sure that you use a "test_" prefix for files with your unit tests.Installing Into Your Dev AAOnce you've cloned or copied all files into place and finished renaming the app, you're ready to install it to your dev AA instance.Make sure you're in your venv. Then install it with pip in editable mode:pipinstall-eaa-your-app-nameFirst add your app to the Django project by adding the name of your app to INSTALLED_APPS insettings/local.py.Next, we will create new migrations for your app:pythonmanage.pymakemigrationsThen run a check to see if everything is set up correctly.pythonmanage.pycheckIn case they're errors make sure to fix them before proceeding.Next, perform migrations to add your model to the database:pythonmanage.pymigrateFinally, restart your AA server and that's it.Installing Into Production AATo install your plugin into a production AA, run this command within the virtual Python environment of your AA installation:pipinstallgit+https://github.com/YourName/aa-your-app-nameAlternatively, you can create a package file and manually upload it to your production AA:pipinstallbuild python-mbuildYou'll find the package under./dist/aa-your-app-name.tar.gzafter this.Install your package directly from the package file:pipinstallaa-your-app-name.tar.gzThen add your app toINSTALLED_APPSinsettings/local.py, run migrations and restart your allianceserver.ContributeIf you've made a new app for AA, please consider sharing it with the rest of the community. For any questions on how to share your app, please contact the AA devs on their Discord. You find the current community creationshere.

aa-fastapi-template

AA FastAPI TemplateA robust and sensible baseline for kick-starting any new FastAPI application. This template provides a comprehensive setup for developing high-performance web applications with FastAPI, including optional, opinionated development and testing dependencies to enhance your development workflow.As of v0.15.10 all dependencies are pinned. Testing and build quality are still a work in progress though. For now everything should work but please check theContributingsection below if you find issues.This package isn't really intended to be used in the same environment as other projects. Since the dependencies here are pinned care should be taken to avoid version conflicts pulled in for other packages.PrerequisitesPython 3.10 or higherpip (Python package installer)Usage# Using pip: pip install aa-fastapi-template # tests pip install aa-fastapi-template[tests] # dev pip install aa-fastapi-template[dev]The base package provides the essential tools for creating FastAPI applications.While[tests]adds testing libraries, the[dev]option installs both the testing and development tools.Package OptionsIncluded within each package are:aa-fastapi-templateaa-fastapi-template[tests]aa-fastapi-template[dev]asyncpg+ aa-fastapi-template+ aa-fastapi-template[tests]environshypothesisblackfastapipytesthttpxmypypytest-covisortpsycopg2-binarypytest-emojiruffpydanticpytest-mdtypespython-dotenvpytest-mocktypes-tomlsqlalchemypytest-xdistsqlmodeltoxuvicornContributingWe welcome contributions to the AA FastAPI Template! If you'd like to contribute, please fork the repository and use a feature branch. Pull requests are warmly welcome.Issues: Use theGitHub Issues pagePull Requests: Submit pull requests with your changes/fixes.

aafigure

This package provides a moduleaafigure, that can be used from other programs, and a command line toolaafigure.Example, test.txt:+-----+ ^ | | | --->+ +---o---> | | | +-----+ VCommand:aafigure test.txt -t svg -o test.svgPlease see documentation for examples.http://aafigure.readthedocs.io/

aafitrans

Aafitrans (AstroAlign FInd TRANSform)Aafitrans is a Python package that builds upon the capabilities of the Astroalign package'sfind_transformfunction. It incorporates several modifications to improve its functionality and performance:Enhanced RANSAC Algorithm: The RANSAC algorithm used in Aafitrans has been optimized to provide a solution that minimizes the sum of squared residuals. This improvement ensures a more accurate transformation estimation.Arun and Horn's Method: Aafitrans replaces Umeyama's method fromscikit-imagewith Arun and Horn's method for estimating'euclidean'or'similarity'transformations.Reflection Support: Unlike Astroalign, Aafitrans enables the matching of coordinate lists that include reflection along one axis. This enhancement expands the range of transformations that can be accurately estimated.Extended Transformation Options: Aafitrans supports all transformations available in thescikit-imagelibrary, providing a comprehensive set of options for aligning and transforming images.Note: only'euclidean','similarity', and'affine'transformations have been tested.Improved Matching Efficiency: Thekdtree_search_radiusparameter in Aafitrans allows users to set the search radius for matches, enabling faster and more efficient matching of corresponding points between images.Reproducible Results: Aafitrans introduces theseedparameter, which can be set during each run to ensure the reproducibility of results. This feature is particularly useful for research and debugging purposes.Dependency Optimization: Aafitrans eliminates the need for thesepandbottleneckpackages as dependencies, streamlining the installation process and reducing potential compatibility issues.Please see the original Astroalign software athttps://github.com/quatrope/astroalignCitation:Astroalign: A Python module for astronomical image registration. Beroiz, M., Cabral, J. B., & Sanchez, B. Astronomy & Computing, Volume 32, July 2020, 100384.InstallationpipinstallaafitransUsageIt is similar to Astroalign'sfind_transformfunction. However, there are many parameters available for the user to modify.fromaafitransimportfind_transformtransf,(matched_source_xy,matched_target_xy)=find_transform(source_xy,target_xy,max_control_points=50,ttype='similarity',pixel_tolerance=2,min_matches=4,num_nearest_neighbors=8,kdtree_search_radius=0.02,n_samples=1,get_best_fit=True,seed=None)WARNING:The Astroalignfind_transformfunction takes both coordinate lists and images as input, while the Aafitransfind_transformfunction only takes coordinate lists as input.Documentation forfind_transformfunctionThefind_transformfunction estimates the transform between two sets of control points, source and target. It returns a GeometricTransform objectT(see scikit-image documentation for details) that maps pixel x, y indices from the source image s = (x, y) into the target (destination) image t = (x, y).Parameters:source: An iterable of (x, y) coordinates of the source control points.target: An iterable of (x, y) coordinates of the target control points.max_control_points: Default value is 50. The maximum number of control points to find the transformation.ttype: Default value is'similarity'. The type of transform to be estimated. One of the following should be set: {'euclidean','similarity','affine','piecewise-affine','projective','polynomial'}. For details, seescikit-image documentation.pixel_tolerance: The maximum residual error for the estimated tranform.min_matches: The minimum number of matches to be found. A value of 1 refers to 1 triangle, corresponding to 3 pairs of coordinates.num_nearest_neighbors: The number of nearest neighbors of a given star (including itself) to construct the triangle invariants.kdtree_search_radius: The default is 0.02. This radius is used to find nearest neighbours while conducting a KD tree search of invariant features.n_samples: The minimum number of data points to fit the model to. A value of 1 refers to 1 triangle, corresponding to 3 pairs of coordinates.get_best_fit: Whether to minimize the total error.seed: Seed value for Numpy Random Generator.Returns:T: GeometricTransform object that maps pixel x, y indices from the source image s = (x, y) into the target (destination) image t = (x, y). It contains parameters of the transformation.(source_pos_array, target_pos_array): A tuple of corresponding star positions in source and target.Raises:TypeError: If input type ofsourceortargetis not supported.ValueError: If it cannot find more than 3 stars on any input.MaxIterError: If no transformation is found.

aa-fleet

Fleet plugin app for Alliance AuthThis is an fleet plugin app forAlliance Auth(AA).FeaturesAlliance Fleet offers the following main features:Create a fleet advert on authRestrict fleet advert to some AuthGroupsSet MOTD and Free Move from authAutomaticly kill the fleet advert if the creator is out of fleet or changed fleetInvite any character related to the user on authFC View with an aggregation of ships in fleet with variation each 60 secondsInstallation1. Install appInstall into your Alliance Auth virtual envrionment from githubpipinstallaa-fleet2. Update Eve Online appupdate the Eve Online app used for authentication in your AA installation to include the following scopes:esi-fleets.read_fleet.v1 esi-fleets.write_fleet.v13. Configure AA settingsConfigure your AA settings ('local.py') as follows:Add'fleet'toINSTALLED_APPAdd these lines to the bottom of your settings file:#settings for fleetCELERYBEAT_SCHEDULE['fleet_check_fleet_adverts']={'task':'fleet.tasks.check_fleet_adverts','schedule':crontab(minute='*/1'),}4. Finalize installation into AARun migrations & copy static filespythonmanage.pymigrate pythonmanage.pycollectstaticRestart your supervisor services for AA5. Setup permissionsNow you can access Alliance Auth and setup permissions for your users. See sectionPermissionsbelow for details.UpdatingTo update your existing installation of Alliance Fleet first enable your virtual environment.Then run the following commands from your AA project directory (the one that containsmanage.py).pipinstall-Uaa-fleetpythonmanage.pymigratepythonmanage.pycollectstaticFinally restart your AA supervisor services.PermissionsThis is an overview of all permissions used by this app:NamePurposeCodeCan add / manage fleetsLet a user create and update fleet informationmanageCan access this appEnabling the app for a user. This permission should be enabled for everyone who is allowed to use the app (e.g. Member state)fleet_access

aa-fleetfinder

AA Fleet FinderControl access to your fleets through Alliance Auth.AA Fleet FinderInstallationStep 1: Install the PackageStep 2: Configure Alliance AuthStep 3: Add the Scheduled TaskStep 4: Finalizing the InstallationStep 4: Setup PermissionsChangelogTranslation StatusContributingInstallationStep 1: Install the PackageMake sure you're in the virtual environment (venv) of your Alliance Auth installation Then install the latest release directly from PyPi.pipinstallaa-fleetfinderStep 2: Configure Alliance AuthThis is fairly simple, just add the following to theINSTALLED_APPSof yourlocal.pyConfigure your AA settings (local.py) as follows:Add"fleetfinder",toINSTALLED_APPSStep 3: Add the Scheduled TaskTo set up the scheduled task, add the following code to yourlocal.py:# AA Fleetfinder - https://github.com/ppfeufer/aa-fleetfinderif"fleetfinder"inINSTALLED_APPS:CELERYBEAT_SCHEDULE["fleetfinder_check_fleet_adverts"]={"task":"fleetfinder.tasks.check_fleet_adverts","schedule":crontab(minute="*/1"),}Step 4: Finalizing the InstallationRun static files collection and migrationspythonmanage.pycollectstatic pythonmanage.pymigrateStep 4: Setup PermissionsNow it's time to set up access permissions for your new Fleetfinder module.IDDescriptionNotesaccess_fleetfinderCan access the Fleetfinder moduleYour line members should have this permission, together with everyone you want to have access to he module.manage_fleetsCan manage fleetsEveryone with this permission can open and edit fleetsChangelogSeeCHANGELOG.mdTranslation StatusDo you want to help translate this app into your language or improve the existing translation? -Join our team of translators!ContributingYou 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)

aa-fleetpings

AA Fleet PingsApp for Alliance Auth that can format your fleet pings and also ping for you to Discord.AA Fleet PingsInstallation⚠️ Important ⚠️Step 1: Install the AppStep 2: Update Your AA SettingsStep 3: Finalizing the InstallationStep 4: Setting up PermissionStep 5: Setting up the AppUpdatingScreenshotsView in Alliance AuthDiscord Ping ExampleConfigurationUse Default Fleet TypesUse Default Ping TargetsUse Doctrines From Fittings ModuleWebhook VerificationDefault Embed ColorChangelogTranslation StatusContributingInstallation⚠️ Important ⚠️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)⚠️ You also want to make sure that you have theDiscord serviceinstalled, configured and activated before installing this app. ⚠️Step 1: Install the AppMake sure you're in the virtual environment (venv) of your Alliance Auth installation. Then install the latest version:pipinstallaa-fleetpingsStep 2: Update Your AA SettingsConfigure your AA settings (local.py) as follows:Add'fleetpings',toINSTALLED_APPSStep 3: Finalizing the InstallationCopy static files and run migrationspythonmanage.pycollectstatic pythonmanage.pymigrateRestart your supervisor services for AAStep 4: Setting up PermissionNow you can set up permissions in Alliance Auth for your users. Addfleetpings | aa fleetpings | Can access this appto the states and/or groups you would like to have access.Step 5: Setting up the AppIn your admin backend you'll find a new section calledFleet Pings. This is where you set all your stuff up, like the webhooks you want to ping and who can ping them, fleet types, comms, formup locations, and so on. It's pretty straight forward, so you shouldn't have any issues. Go nuts!UpdatingTo update your existing installation of AA Discord Ping Formatter, first enable your virtual environment.Then run the following commands from your AA project directory (the one that containsmanage.py).pipinstall-Uaa-fleetpings pythonmanage.pycollectstatic pythonmanage.pymigrateFinally, restart your AA supervisor services.ScreenshotsView in Alliance AuthDiscord Ping ExampleConfigurationThe following settings are available in the Django Admin Backend under/admin/fleetpings/setting/:Use Default Fleet TypesEnable or disable the default fleet types (Roaming, Home Defense, StratOP, and CTA) that are shown in the fleet type dropdown in addition to your own.Default:TrueUse Default Ping TargetsEnable or disable the default ping targets (@everyone and @here) that are shown in the ping target dropdown in addition to your own.Default:TrueUse Doctrines From Fittings ModuleIf you have theFittings and Doctrinesmodule installed, and your doctrines configured there, you don't have to re-build your doctrine list for this module. You can simply use the doctrines you already have configured in the Fittings and Doctrines module.Default:TrueWebhook VerificationIf you require your pings to be sent to a webhook, that is not a standard discord webhook.When disabling webhook verification and using non-Discord webhooks, it is up to you to make sure your webhook understands a payload that is formatted for Discord webhooks.Default:TrueDefault Embed ColorThe default highlight for the embed, that is used when no other highlight color is defined.Default:#FAA61AChangelogSeeCHANGELOG.mdTranslation StatusDo you want to help translate this app into your language or improve the existing translation? -Join our team of translators!ContributingYou 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)

aa-fleettools

aa-fleettools

aa-forum

AA ForumSimple forum app forAlliance AuthAA Forum⚠️ Before You Install This Module ⚠️OverviewFeaturesScreenshotsForum IndexTopic Overview / Board IndexTopic ViewStart New Topic (ckEditor)Admin ViewInstallationImportant: Please Make Sure You Meet All Preconditions Before You Proceed:Step 1: Install the PackageStep 2: Configure Alliance AuthSettings in/home/allianceserver/myauth/myauth/settings/local.pySettings in/home/allianceserver/myauth/myauth/urls.pyStep 3: Configure Your WebserverApacheNginxStep 4: Finalizing the InstallationStep 5: Setting up PermissionsChangelogTranslation StatusContributing⚠️ Before You Install This Module ⚠️This module needs quite some configuration done before working properly. You need to modify your Apache/Nginx configuration as well as the global URL config of Alliance Auth. So please only install if you know what you're doing/feel comfortable making these kinds of changes. For your own sanity, and mine :-)OverviewFeaturesSimple permission system. Only 2 permissions. ("has_access" and "can_manage")Simple administration, no maze to click through to get where you want to go.Categories and boards are sortable via drag and drop in the admin view.Mass creation of boards with a new category.Boards can be restricted to 1 or more groups, boards without restrictions are visible for everyone who has access to the forum.Announcement boards where only certain users can start topics.Child boards (1 Level), which inherit their access restrictions from their parent.CKEditor with image upload.Unread topics counter as a number on the "Forum" link in the left navigation.Optional notifications about new topics in a board via Discord webhooks.Forum profile for each user.Personal Messages.Optional Discord PM for new personal messages.This feature is disabled by default, can be enabled by each user in their forum profile. Needs one of the following applications installed:discordproxyAA-DiscordbotScreenshotsForum IndexTopic Overview / Board IndexTopic ViewStart New Topic (ckEditor)Admin ViewInstallationImportant: Please Make Sure You Meet All Preconditions Before You Proceed:AA Forum 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)AA Forum needs a couple of changes made to your Webserver and Alliance Auth configuration. So make sure you know how to do so. The steps needed will be described in this document, but you need to understand what will be changed.Step 1: Install the PackageMake sure you're in the virtual environment (venv) of your Alliance Auth installation Then install the latest release directly from PyPi.pipinstallaa-forumStep 2: Configure Alliance AuthSettings in/home/allianceserver/myauth/myauth/settings/local.pyThis is fairly simple, configure your AA settings (local.py) as follows:# AA ForumINSTALLED_APPS+=["ckeditor","ckeditor_uploader","django_ckeditor_youtube_plugin","aa_forum",# https://github.com/ppfeufer/aa-forum]if"ckeditor"inINSTALLED_APPS:# ckEditorimportckeditor.configsMEDIA_URL="/media/"MEDIA_ROOT="/var/www/myauth/media/"X_FRAME_OPTIONS="SAMEORIGIN"CKEDITOR_UPLOAD_PATH="uploads/"CKEDITOR_RESTRICT_BY_USER=TrueCKEDITOR_ALLOW_NONIMAGE_FILES=False# Editor configuration## If you already have this from another app, like `aa-bulletin-board`, you don't# need to define this again, just add it to the `CKEDITOR_CONFIGS` dict, see below## You can extend and change this to your needs# Some of the options are commented out, feel free to play around with themckeditor_default_config={"width":"100%","height":"45vh","youtube_responsive":True,"youtube_privacy":True,"youtube_related":False,"youtube_width":1920,"youtube_height":1080,"extraPlugins":",".join(["uploadimage",# "div","autolink",# "autoembed",# "embedsemantic","clipboard","elementspath",# "codesnippet","youtube",]),"toolbar":[{"name":"styles","items":["Styles","Format",# "Font",# "FontSize",],},{"name":"basicstyles","items":["Bold","Italic","Underline","Strike",# "Subscript",# "Superscript",# "-",# "RemoveFormat",],},{"name":"clipboard","items":[# "Cut",# "Copy",# "Paste",# "PasteText",# "PasteFromWord",# "-","Undo","Redo",],},{"name":"links","items":["Link","Unlink","Anchor",],},{"name":"insert","items":["Image","Youtube","Table","HorizontalRule","Smiley","SpecialChar",# "PageBreak",# "Iframe",],},{"name":"colors","items":["TextColor","BGColor",],},{"name":"document","items":[# "Source",# "-",# "Save",# "NewPage",# "Preview",# "Print",# "-",# "Templates",],},],}# Add the external YouTube pluginaa_forum__external_plugin_resources=[("youtube","/static/ckeditor/ckeditor/plugins/youtube/","plugin.min.js",)]# Put it all togetherCKEDITOR_CONFIGS={"default":ckeditor.configs.DEFAULT_CONFIG,"aa_forum":ckeditor_default_config,}CKEDITOR_CONFIGS["aa_forum"]["external_plugin_resources"]=aa_forum__external_plugin_resourcesSettings in/home/allianceserver/myauth/myauth/urls.pyNow let's move on to editing the global URL configuration of Alliance Auth. To do so, you need to open/home/allianceserver/myauth/myauth/urls.pyand change the following block right before thehandlerdefinitions:# URL configuration for cKeditorfromdjango.appsimportappsifapps.is_installed("ckeditor"):# Djangofromdjango.contrib.auth.decoratorsimportlogin_requiredfromdjango.views.decorators.cacheimportnever_cache# ckEditorfromckeditor_uploaderimportviewsasckeditor_viewsurlpatterns=[re_path(r"^upload/",login_required(ckeditor_views.upload),name="ckeditor_upload"),re_path(r"^browse/",never_cache(login_required(ckeditor_views.browse)),name="ckeditor_browse",),]+urlpatternsAfter this, yoururls.pyshould look similar to this:fromdjango.urlsimportinclude,re_pathfromallianceauthimporturls# Alliance auth urlsurlpatterns=[re_path(r"",include(urls)),]# URL configuration for cKeditorfromdjango.appsimportappsifapps.is_installed("ckeditor"):# Djangofromdjango.contrib.auth.decoratorsimportlogin_requiredfromdjango.views.decorators.cacheimportnever_cache# ckEditorfromckeditor_uploaderimportviewsasckeditor_viewsurlpatterns=[re_path(r"^upload/",login_required(ckeditor_views.upload),name="ckeditor_upload"),re_path(r"^browse/",never_cache(login_required(ckeditor_views.browse)),name="ckeditor_browse",),]+urlpatternshandler500="allianceauth.views.Generic500Redirect"handler404="allianceauth.views.Generic404Redirect"handler403="allianceauth.views.Generic403Redirect"handler400="allianceauth.views.Generic400Redirect"Step 3: Configure Your WebserverYour webserver needs to know from where to serve the uploaded images, of course, so we have to tell it.ApacheIn your vhost configuration, you have a lineProxyPassMatch ^/static !, which tells the server where to find all the static files. We're adding a similar line for the media, right below that one.Add the following right below the static proxy match:ProxyPassMatch^/media!Now we also need to let the server know where to find the media directory we just configured the proxy for. To do so, add a new Alias to your configuration. This can be done right below the already existing Alias for/static:Alias"/media""/var/www/myauth/media/"At last, a "Directory" rule is needed as well. Add the following code below the already existing Directory rule for the static files:<Directory"/var/www/myauth/media/">Requireallgranted</Directory>So the whole block should now look like this:ProxyPassMatch^/static!ProxyPassMatch^/media!#***NEWproxyruleProxyPass/http://127.0.0.1:8000/ProxyPassReverse/http://127.0.0.1:8000/ProxyPreserveHostOnAlias"/static""/var/www/myauth/static/"Alias"/media""/var/www/myauth/media/"<Directory"/var/www/myauth/static/">Requireallgranted</Directory><Directory"/var/www/myauth/media/">Requireallgranted</Directory>Restart your Apache webserver.NginxIn order to let Nginx know where to find the uploaded files, you need to add a new location rule to the configuration. Add the following right below the definition for your "static" location.location/media{alias/var/www/myauth/media;autoindexoff;}Restart your Nginx webserver.Step 4: Finalizing the InstallationRun static files collection and migrationspythonmanage.pycollectstatic pythonmanage.pymigrateRestart your supervisor services for AuthStep 5: Setting up PermissionsNow it's time to set up access permissions for your new module. You can do so in your admin backend.IDDescriptionNotesbasic_accessCan access the AA-Forum moduleGrants access to the forummanage_forumCan manage the AA-Forum module (Categories, topics and messages)Users with this permission can create, edit and delete boards and categories in the "Administration" view. They can also modify and delete messages and topics in the "Forum" view.Users with this permission are not bound by group restrictions and have access to all boards and topics, so choose wisely who is getting this permission.ChangelogSeeCHANGELOG.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)

aafp-database-connection

No description available on PyPI.

aafragpy

aafragpyPython implementation of secondary particle production model AAFrag (based on QGSJEt-II-04m). The code is modified after the original AAFrag code written on Fortran [1].This package allows to quickly reconstruct the differential cross-sections of secondary gammas, leptons, and hadrons producing in a result of hadronic interaction between primary hadrons and different targets.The package allows to calculate the spectrum of products knowing the spectra of primary particles and the composition of the target in the wide energy range from hundreds of MeV to EeVs.Additional consideration of low-energy nuclear interactions is also possible using Kamae et al. 2006 [2] and Kafexhiu et al. 2014 [3] codes.InstallationThe package is easy to install using pip:pip install aafragpyInteractive TutorialTutorial of package usage is given in interactive Jupiter Notebook.You can also get started quickly using cloud serviceBinderto run the tutorial in your web browser within a remote server:Comments are welcome!If you are using aafragpy, please cite us as:S. Koldobskiy, M. Kachelrieß, A. Lskavyan, A. Neronov, S. Ostapchenko, and D. V. Semikoz, “Energy spectra of secondaries in proton-proton interactions,”Phys. Rev. D, vol. 104, no. 12, p. 123027, 2021,arXiv:2110.00496.References:[1] M. Kachelrieß, I. V. Moskalenko, and S. Ostapchenko, “AAfrag: Interpolation routines for Monte Carlo results on secondary production in proton-proton, proton-nucleus and nucleus-nucleus interactions,”Comput. Phys. Commun., vol. 245, p. 106846, 2019.[2] T. Kamae, N. Karlsson, T. Mizuno, T. Abe, and T. Koi, “Parameterization of γ, e+-, and Neutrino Spectra Produced by p-p Interaction in Astronomical Environments,”Astrophys. J., vol. 647, no. 1, pp. 692–708, 2006.[3] E. Kafexhiu, F. Aharonian, A. M. Taylor, and G. S. Vila, “Parametrization of gamma-ray production cross-sections for pp interactions in a broad proton energy range from the kinematic threshold to PeV energies,”Phys. Rev. D, vol. 90, no. 12, pp. 1–19, 2014.

aafragpy-serkol

aafragpyPython implementation of secondary particle production model AAFrag (based on QGSJEt-II-04m). The code is modified after the original AAFrag code written on Fortran [1].This package allows to quickly reconstruct the differential cross-sections of secondary gammas, leptons, and hadrons producing in a result of hadronic interaction between primary hadrons and different targets.The package allows to calculate the spectrum of products knowing the spectra of primary particles and the composition of the target in the wide energy range from hundreds of MeV to EeVs.Additional consideration of low-energy nuclear interactions is also possible using Kamae et al. 2006 [2] and Kafexhiu et al. 2014 [3] codes.InstallationThe package is easy to install using pip:pip install -i https://test.pypi.org/simple/ aafragpy-serkolTutorialTutorial of package usage is given in the Jupiter Notebook.You can also get started quickly usingBinderto run the tutorial in your web browser within a remote server:Comments are welcome!If you are using aafragpy, please cite us as:TBAReferences:[1] M. Kachelrieß, I. V. Moskalenko, and S. Ostapchenko, “AAfrag: Interpolation routines for Monte Carlo results on secondary production in proton-proton, proton-nucleus and nucleus-nucleus interactions,” Comput. Phys. Commun., vol. 245, p. 106846, 2019.https://doi.org/10.1016/j.cpc.2019.08.001[2] T. Kamae, N. Karlsson, T. Mizuno, T. Abe, and T. Koi, “Parameterization of γ, e+-, and Neutrino Spectra Produced by p-p Interaction in Astronomical Environments,” Astrophys. J., vol. 647, no. 1, pp. 692–708, Aug. 2006.https://doi.org/10.1086/505189[3] E. Kafexhiu, F. Aharonian, A. M. Taylor, and G. S. Vila, “Parametrization of gamma-ray production cross-sections for pp interactions in a broad proton energy range from the kinematic threshold to PeV energies,” Phys. Rev. D - Part. Fields, Gravit. Cosmol., vol. 90, no. 12, pp. 1–19, Jun. 2014.https://doi.org/10.1103/PhysRevD.90.123014

aa-freight

Freight for Alliance AuthFreight is anAlliance Auth(AA) app for running a freight service.ContentsOverviewKey FeaturesScreenshotsInstallationUpdatingSettingsOperation ModePermissionsPricingContract CheckChange LogOverviewThis app helps running a central freight service for an alliance or corporation. It allows different modes of operation that support the most common approaches a central freight service is setup. (e.g. for alliance members only or run by a corporation outside the alliance)Key FeaturesFreight offers the following main features:Reward calculator allowing members to easily calculate the correct reward for their a courier contractPage showing the list of currently outstanding courier contracts incl. an indicator if the contract is compliant with the pricing for the respective route ("contract check")Multiple routes can be defined, each with its own pricing.It's possible to have the same pricing for both directions, or to have different pricings for each direction of the same route.Automatic notifications to freight pilots on Discord informing them about new courier contractsAutomatic notifications to contract issuers on Discord informing them about the developing status of their contract or potentially issuesContract issuer can always check the current status of his courier contractsStatistics page showing key performance metrics for routes, pilots, customersLanguage support for English 🇺🇸 and German 🇩🇪ScreenshotsReward CalculatorContract ListDiscord NotificationInstallation1 - Install appInstall into your Alliance Auth virtual environment from PyPI:pipinstallaa-freight2 - Update Eve Online appUpdate the Eve Online app used for authentication in your AA installation to include the following scopes:esi-universe.read_structures.v1 esi-contracts.read_corporation_contracts.v13 - Configure AA settingsConfigure your AA settings (local.py) as follows:Add'freight'toINSTALLED_APPSAdd these lines add to bottom of your settings file:# settings for freightCELERYBEAT_SCHEDULE['freight_run_contracts_sync']={'task':'freight.tasks.run_contracts_sync','schedule':crontab(minute='*/10'),}If you want to setup notifications for Discord you can now also add the required settings. Check out sectionSettingsfor details.3a - Celery setupThis app uses celery for critical functions like refreshing data from ESI. We strongly recommend to enable the following additional settings for celery workers to enable proper logging and to protect against potential memory leaks:To enable logging of celery tasks up to info level:-l infoTo automatically restart workers that grow above 256 MB:--max-memory-per-child 262144Here is how an example config would look for workers in your supervisor conf:command=/home/allianceserver/venv/auth/bin/celery -A myauth worker -l info --max-memory-per-child 262144On Ubuntu you can runsystemctl status supervisorto see where your supervisor config file is located.Note that you need to restart the supervisor service itself to activate those changes.e.g. on Ubuntu:systemctlrestartsupervisor4 - Finalize installation into AARun migrations & copy static filespythonmanage.pymigrate pythonmanage.pycollectstaticRestart your supervisor services for AA5 - Setup permissionsNow you can access Alliance Auth and setup permissions for your users. See sectionPermissionsbelow for details.6 - Setup contract handlerFinally you need to set the contract handler with the character that will be used for fetching the corporation or alliance contracts and related structures. Just click on "Set Contract Handler" and add the requested token. Note that only users with the appropriate permission will be able to see and use this function. However, the respective character does not need any special corporation roles. Any corp member will work.Once a contract handler is set the app will start fetching contracts. Wait a minute and then reload the contract list page to see the result.7 - Define pricingFinally go ahead and define the first pricing of a courier route. See sectionPricingfor details.That's it. The Freight app is fully installed and ready to be used.8 - Setup Discord Proxy (optional)If you want Freight to send contract updates as direct messages to your users you need to haveDiscord Proxyrunning. You also need to have Discord Proxy installed in the same Python venv like Freight.Once Discord Proxy is running just setFREIGHT_DISCORDPROXY_ENABLED = Truein your local settings to enable this feature.For details on how to setup Discord Proxy (if you don't have it running already) please see theinstallation documentation.UpdatingTo update your existing installation of Freight first enable your virtual environment.Then run the following commands from your AA project directory (the one that containsmanage.py).pipinstall-Uaa-freightpythonmanage.pymigratepythonmanage.pycollectstaticFinally restart your AA supervisor services.SettingsHere is a list of available settings for this app. They can be configured by adding them to your AA settings file (local.py). If they are not set the defaults are used.NameDescriptionDefaultFREIGHT_APP_NAMEName of this app as shown in the Auth sidebar, page titles and as default avatar name for notifications.'Freight'FREIGHT_CONTRACT_SYNC_GRACE_MINUTESSets the number minutes until a delayed sync will be recognized as error30FREIGHT_DISCORD_DISABLE_BRANDINGTurns off setting the name and avatar url for the webhook. Notifications will be posted by a bot called "Freight" with the logo of your organization as avatar imageFalseFREIGHT_DISCORDPROXY_ENABLEDWhether to use Discord Proxy for sending customer notifications as direct messages. Obviously requires Discord Proxy to be setup and running on your system and the Discord Services to be enabled.FalseFREIGHT_DISCORDPROXY_PORTTCP port on which Discord Proxy is running.50051FREIGHT_DISCORD_MENTIONSOptional mention string put in front of every notification to create pings: Typical values are:@hereor@everyone. You can also mention roles, however you will need to add the role ID for that. The format is:<@&role_id>and you can get the role ID by entering_<@role_name>in a channel on Discord. Seethis linkfor details.''FREIGHT_DISCORD_WEBHOOK_URLWebhook URL for the Discord channel where contract notifications for pilots should appear.NoneFREIGHT_DISCORD_CUSTOMERS_WEBHOOK_URLWebhook URL for the Discord channel where contract notifications for customers should appear.NoneFREIGHT_FULL_ROUTE_NAMESShow full name of locations in route, e.g on calculator drop downFalseFREIGHT_HOURS_UNTIL_STALE_STATUSDefines after how many hours the status of a contract is considered to be stale. Customer notifications will not be sent for a contract status that has become stale. This settings also prevents the app from sending out customer notifications for old contracts.24FREIGHT_OPERATION_MODESee sectionOperation Modefor details.Note that switching operation modes requires you to remove the existing contract handler with all its contracts and then setup a new contract handler'my_alliance'FREIGHT_STATISTICS_MAX_DAYSSets the number of days that are considered for creating the statistics90FREIGHT_NOTIFY_ALL_CONTRACTSSends all contracts notifications, even if they do not have corresponding pricingFalseOperation ModeThe operation mode defines which contracts are processed by the Freight. For example you can define that only contracts assigned to your alliance are processed. Any courier contract that is not in scope of the configured operation mode will be ignored by the freight app and e.g. not show up in the contract list or generate notifications.The following operation modes are available:NameDescription'my_alliance'courier contracts assigned to configured alliance by an alliance member'my_corporation'courier contracts assigned to configured corporation by a corp member'corp_in_alliance'courier contracts assigned to configured corporation by an alliance member'corp_public'any courier contract assigned to the configured corporationPermissionsThis is an overview of all permissions used by this app:NamePurposeCodeCan add / update locationsUser can add and update Eve Online contract locations, e.g. stations and upwell structuresadd_locationCan access this appEnabling the app for a user. This permission should be enabled for everyone who is allowed to use the app (e.g. Member state)basic_accessCan setup contract handlerAdd or updates the character for syncing contracts. This should be limited to users with admins / leadership privileges. Note that characters need to retain that permission for the update process to continue to function.setup_contract_handlerCan use the calculatorEnables using the calculator page and the "My Contracts" page. This permission is usually enabled for every user with the member state.use_calculatorCan view the contracts listEnables viewing the page with all outstanding courier contractsview_contractsCan see statisticsUser with this permission can view the statistics pageview_statisticsPricingA pricing defines a route and the parameters for calculating the price for that route along with some additional information for the users. You can define multiple pricings if you want, but at least one pricing has to be defined for this app to work.Pricing routes are bidirectional by default. For bidirectional pricings courier contracts in both directions are matched against the same pricing. Alternatively pricings can also be defined individually for each direction.Pricings are defined in the admin section of AA, so you need staff permissions to access it.Most parameters of a pricing are optional, but you need to define at least one of the four pricing components to create a valid pricing. It's also possible to define a route that does not require a reward by setting "Price base" to 0 and not setting any other pricing components.All pricing parameters can be found on the admin panel under Pricing, with the exception of the "price per volume modifier", which is a global pricing parameter and therefore property of the ContractHandler.ParameterDescriptionPricing FunctionalityStart LocationStarting station or structure for courier route-End LocationDestination station or structure for courier route-Is ActiveNon active pricings will not be used or shown-Is BidirectionalWether this pricing shall apply to contracts for both directions of the route or only the specified direction-Price baseBase price in ISK. If this is the only defined pricing component it will be shown as "Fix price" in the calculator.Pricing componentPrice minMinimum total price in ISKPricing componentPrice per volumeAdd-on price per m3 volume in ISKPricing componentUse price per volume modifierSwitch defining if the global price per volume modifier should be used for pricingPricing flagPrice per volume modifierGlobal modifier for price per volume in percent.The purpose of this modifier is to be able to compensate for fuel price fluctuations, without having to adjust pricing for many individual routes. When used it will be added to the price per volume. It can be positive and negative, and the resulting price per volume will always be >= 0.e.g. if you have set a price of 200 ISK per m3 on a route, and set the global modifier to 10% then you get 220 ISK per m3 effectively.(defined for ContractHandler)Pricing modifierPrice per collateral_percentAdd-on price in % of collateralPricing componentCollateral minMinimum required collateral in ISKValidation checkCollateral maxMaximum allowed collateral in ISKValidation checkVolume minMinimum allowed volume in m3Validation checkVolume maxMaximum allowed volume in m3Validation checkDays to expireRecommended days for contracts to expireInfoDays to completeRecommended days for contract completionInfoDetailsText with additional instructions for using this pricingInfoHow to add new locations:If you are creating a pricing for a new route you may need to first add the locations (stations and/or structures).The easiest way is to create a courier contract between those locations in game and then run contract sync. Those locations will then be added automatically.Alternatively you can use the "Add Location" feature on the main page of the app. This will require you to provide the respective station or structure eve ID.Contract CheckThe app will automatically check if a newly issued contract complies with the pricing parameters for the respective route. If you want to be notified about all contracts, even without correct pricing, setFREIGHT_NOTIFY_ALL_CONTRACTSoption toTrueCompliant contracts will have a green checkmark (✓) in the "Contract Check" column on the contract list. Related notifications on Discord will be colored in green.Non-compliant contracts will have a red warning sign in the "Contract Check" column on the contract list. And related notifications on Discord will be colored in red. In addition the first customer notification will inform the customer about the issues and ask him to correct the issues.The following parameters will be checked (if they have been defined):reward in contract >= calculated rewardvolume min <= volume in contract <= volume maxcollateral min <= collateral in contract <= collateral maxDeviations on "Days to expire" and "Days to complete" are currently not part of the contract check and only used to show the recommended contract parameters in the calculator.

aa-gdpr

AA-GDPRA Collection of overrides and resources to help Alliance Auth installs meet GDPR legislation.This Repository cannot guarantee your Legal requirements but aims to reduce the technical burden on Web/System AdministratorsCurrent FeaturesOverrides Alliance Auth default resource bundles to use staticfile delivery.Local staticfile delivery of resources to avoid using CDNsJavascriptLess 3.12.2, 4.1.2Moment.js 2.27, 2.29.1https://github.com/moment/momentjQuery 2.2.4, 3.6.0https://github.com/jquery/jqueryjQuery-DateTimePicker 2.5.20https://github.com/xdan/datetimepickerjQuery-UI 1.12.1https://jqueryui.com/Twitter-Bootstrap 3.4.1, 4.4.1, 4.5.2, 4.6.1, 5.0.1https://github.com/twbs/bootstrapx-editable 1.5.1http://vitalets.github.io/x-editableLess 2.7.3 & 3.12.2http://lesscss.org/DataTables 1.10.21http://datatables.net/Clipboard.js 2.0.6, 2.0.8https://clipboardjs.com/FontsFontAwesome 5.11.2, 5.14.0, 5.15.4https://github.com/FortAwesome/Font-AwesomeOFL Lato 16https://fonts.google.com/specimen/LatoCSSDataTables 1.10.21http://datatables.net/FontAwesome 5.11.2, 5.14.0, 5.15.4https://github.com/FortAwesome/Font-AwesomejQuery-DateTimePicker 2.5.20https://github.com/xdan/datetimepickerjQuery-UI 1.12.1https://jqueryui.com/x-editable 1.5.1http://vitalets.github.io/x-editablePlanned FeaturesConsent ManagementTerms of Use ManagementData TransparencyRight to be Forgotten RequestsInstallationStep One - InstallInstall the app with your venv activepipinstallaa-gdprStep Two - ConfigureAddINSTALLED_APPS.insert(0, 'aagdpr')right before yourINSTALLED_APPSlist in your projectslocal.pyAdd the below lines to yourlocal.pysettings file## Settings for AA-GDPR ### Instruct third party apps to avoid CDNsAVOID_CDN=FalseStep Three - Update ProjectRun migrationspython manage.py migrate(There should be none yet)Gather your staticfilespython manage.py collectstaticSettingsAVOID_CDN - Will attempt to instruct third party applications to attempt to load CSS JS and Fonts from staticfiles, DefaultFalse.

aa-gen

Simple Ascii Art Generatoraa-gen is a simple ascii art generator that can turn the input text into ascii art for output.Example$aa-gen-tPython.....ex45PPP55M.5l5E455Reset+45w@@5E@ee@.@eewL+@I3@eMs455575l65`/%5[77555""755l45P""755x455[""P5RI45eeee55" 5R. 45[ 5l 55 55 45[ %5I 45[ 85E45""""` 75s 5[ 5l 5E 45 55 45l 45l 5E45 75L45 5l 5E 45 75L 45` 45l 5E45 555[ 55@@ 5E 45 %5ML.@65[ 45l 5E/7 45[ "7777" /7 "7PP[" /7` 7"5k45[""

aagent

aagentActors and Agents combined.UsingPython package: to add and install this package as a dependency of your project, runpoetry add aagent.Python CLI: to view this app's CLI commands once it's installed, runaagent --help.Python application: to serve this REST API, rundocker compose up appand openlocalhost:8000in your browser. Within the Dev Container, this is equivalent to runningpoe api.ContributingPrerequisites1. Set up Git to use SSHGenerate an SSH keyandadd the SSH key to your GitHub account.Configure SSH to automatically load your SSH keys:cat<< EOF >> ~/.ssh/configHost *AddKeysToAgent yesIgnoreUnknown UseKeychainUseKeychain yesEOF2. Install DockerInstall Docker Desktop.EnableUse Docker Compose V2in Docker Desktop's preferences window.Linux only:Configure Docker to use the BuildKit build system. On macOS and Windows, BuildKit is enabled by default in Docker Desktop.Export your user's user id and group id so thatfiles created in the Dev Container are owned by your user:cat<< EOF >> ~/.bashrcexport UID=$(id --user)export GID=$(id --group)EOF3. Install VS Code or PyCharmInstall VS CodeandVS Code's Dev Containers extension. Alternatively, installPyCharm.Optional:install aNerd Fontsuch asFiraCode Nerd Fontandconfigure VS Codeorconfigure PyCharmto use it.Development environmentsThe following development environments are supported:⭐️GitHub Codespaces: click onCodeand selectCreate codespaceto start a Dev Container withGitHub Codespaces.⭐️Dev Container (with container volume): click onOpen in Dev Containersto clone this repository in a container volume and create a Dev Container with VS Code.Dev Container: clone this repository, open it with VS Code, and runCtrl/⌘+⇧+P→Dev Containers: Reopen in Container.PyCharm: clone this repository, open it with PyCharm, andconfigure Docker Compose as a remote interpreterwith thedevservice.Terminal: clone this repository, open it with your terminal, and rundocker compose up --detach devto start a Dev Container in the background, and then rundocker compose exec dev zshto open a shell prompt in the Dev Container.DevelopingRunpoefrom within the development environment to print a list ofPoe the Poettasks available to run on this project.Runpoetry add {package}from within the development environment to install a run time dependency and add it topyproject.tomlandpoetry.lock. Add--group testor--group devto install a CI or development dependency, respectively.Runpoetry updatefrom within the development environment to upgrade all dependencies to the latest versions allowed bypyproject.toml.

aa-geo-tools

Failed to fetch description. HTTP Status Code: 404

aag-probability

No description available on PyPI.

aa-guessing-game

No description available on PyPI.

aahnik

No description available on PyPI.

aa-hunting

Alliance Auth - Hunting ToolsWe are hunting Rabbits.FeaturesDisplay active targetsLast known Locate and Past Locates for a given targetManage target Alts and their capabilityNote taking on given targetsPlanned FeaturesManage Locator Agent ExpiriesRequest a Locate from available usersGenerate potential targets from kill activityInstallationStep 1 - Install from pippipinstallaa-huntingStep 3 - Configure Auth settingsConfigure your Auth settings (local.py) as follows:Add'hunting'toINSTALLED_APPSAdd below lines to your settings file:## Settings for AA-Hunting# Notifications (Locator Agent Results)CELERYBEAT_SCHEDULE['hunting_pull_notifications']={'task':'hunting.tasks.pull_notifications','schedule':crontab(minute='0',hour='*'),}CELERYBEAT_SCHEDULE['hunting_import_notifications_apps']={'task':'hunting.tasks.import_notifications_apps','schedule':crontab(minute='30',hour='*'),}# Dont hit squizz too hard, im not shipping the agent file incase it updatesCELERYBEAT_SCHEDULE['hunting_import_agents_squizz']={'task':'hunting.tasks.import_agents_squizz','schedule':crontab(minute='0',hour='0',day_of_week='0'),}Step 3 - Maintain Alliance AuthRun migrationspython manage.py migrateGather your staticfilespython manage.py collectstaticRestart your projectsupervisorctl restart myauth:PermissionsPermAdmin SitePermDescriptionbasic_accessnillCan access the Hunting AppCan access the Hunting Apptarget_addnillCan add a Hunting targetCan add a Hunting targettarget_editnillCan edit a Hunting targetCan edit a Target, Add Alts, Modify Ship Typetarget_archivenillCan archive a Hunting targetCanalt_addnillalt_editnillalt_removenilllocator_addtokennilllocator_requestnilllocator_actionnillSettingsNameDescriptionDefaultHUNTING_ENABLE_CORPTOOLS_IMPORTEnable (if Installed) LocateCharMsg's to be pulled from Corp-Tools, for historical informationTrueContributingMake 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.

aai-demo

hello-emoji 🤩hello-emojiis a random smiley generator.installationpip install hello-emojiusageHere are few examples 👇>>> import hello_emoji >>> hello_emoji.hello_emoji() 'Hello 🤣!' >>> hello_emoji.hello_emoji() 'Hello 😋!' >>> hello_emoji.hello_emoji() 'Hello 😊!'Here are few examples usingfromandimportsyntax.>>> from hello_emoji import hello_emoji >>> hello_emoji() 'Hello 😄!' >>> hello_emoji() 'Hello 😍!' >>> hello_emoji() 'Hello 😊!' >>> hello_emoji() 'Hello 😄!' >>> hello_emoji() 'Hello 🤣!'

aai-engine

AAI EngineThe AAI Engine is a computer vision based automation python library, enabling easy desktop automation with legacy applications, citrix environments, webapps and regualar desktop apps.Installationpip install aai-engineLocalpython -m pip install -e c:\<>\<>\aai_engineor if that does not work (permission issue):python3 -m pip install --no-build-isolation -e /example/path/to/aai_engineIf on macos with an m1, create a conda environment to be able to use opencv.brew install miniforge conda init zsh conda create -n aai python=3.8.6 conda activate aai conda install -c conda-forge opencvDocumentationHereis the documentation for the AAI Engine.Buildpython -m buildShould you want to add files not directly under src/aai_engine_package, add them in MANIFEST.in.UsageThe easiest way to capture and edit screenshots is to use the GUI. One can launch the gui by executingaai-engine-guiin the terminal.Using the CLI to Take a screenshotaai-engine-capture '/path/to/where/you/want/to/save/the/screenshot'

aai-face-search-db-builder

AAI Face Search DB BuilderA simple Python script to help clients to add images in a local directory, Amazon S3, or Alibaba Cloud OSS to their Face Search database by calling the db-build API.Installationpip install aai-face-search-db-builderHow to useAfter installation, run the following command to see the required arguments to pass.$ dbbuilder -hNotesThe script will create a sqlite3 database calledimages.dbto keep track of completed tasks.

aai-face-search-db-builder-test

AAI Face Search DB BuilderA simple Python script to help clients to add images in a local directory, Amazon S3, or Alibaba Cloud OSS to their Face Search database by calling the db-build API.Installationpip install aai-face-search-db-builderHow to useAfter installation, run the following command to see the required arguments to pass.$ dbbuilder -hNotesThe script will create a sqlite3 database calledimages.dbto keep track of completed tasks.

aa-inactivity

AA InactivityThis is a player activity monitoring plugin app forAlliance Auth(AA).ContentFeaturesScreenshotsInstallationPermissionsFeaturesAutomatically notify users who become inactive.Automatically notify managers when users become inactive.Approval process for leave of absence requestsCan inform managers about various events via Discord webhookList of inactive usersDefine through policies after how many days a user of absence a user is considered inactiveFetching the last login dates from Member Audit to determine how long a user has been inactiveUsers are notified on Alliance Auth. If you want those notifications to be forwarded as DM on Discord, please check out this app:Discord Notify.ScreenshotsA user creating a new leave of absence request:A manager reviewing a leave of absence request:A manager looking through the list of currently inactive and notified users:InstallationStep 0 - RequirementsThis app needsMember Auditto function. Please make sure it is installed before continuing.Step 1 - Install the PackageMake sure you are in the virtual environment (venv) of your Alliance Auth installation. Then install the newest release from PyPI:pipinstallaa-inactivity`Step 2 - ConfigAddinactivityto yourINSTALLED_APPS, and add the following task definition:CELERYBEAT_SCHEDULE['inactivity_check_inactivity']={'task':'inactivity.tasks.check_inactivity','schedule':crontab(minute=0,hour=0),}Step 3 - Finalize App InstallationRun migrations:pythonmanage.pymigrate pythonmanage.pycollectstaticRestart your supervisor services for AuthPermissionsThis app uses permissions to control access to features.NamePurposeCodegeneral - Can access this appEnabling the app for a user. This permission should be enabled for everyone who is allowed to use the appbasic_accessgeneral - Can manage leave of absence requestsAllows a user to approve/deny loa requests.manage_leave

aa-incursions

Incursions for Alliance AuthIncursion Tools forAlliance Auth.FeaturesAA-Discordbot Cogs for information about active incursions, their status and any set FocusWebhook notifications for new incursions and them changing state (Mobilizing/Withdrawing)Planned FeaturesWaitlistAA Fittings IntegrationSecure Groups IntegrationInstallationStep 1 - Django Eve UniverseIncursions is an App forAlliance Auth, Please make sure you have this installed. incursions is not a standalone Django ApplicationIncursions needs the Appdjango-eveuniverseto function. Please make sure it is installed before continuing.Step 2 - Install apppipinstallaa-incursionsStep 3 - Configure Auth settingsConfigure your Auth settings (local.py) as follows:Add'incursions'toINSTALLED_APPSAdd below lines to your settings file:## Settings for AA-Incursions ### Route is Cached for 300 Seconds, if you aren't riding the Kundalini Manifest to the last minute# Feel free to adjust this to minute='*/5'CELERYBEAT_SCHEDULE['incursions_update_incursions']={'task':'incursions.tasks.update_incursions','schedule':crontab(minute='*/1',hour='*'),}Step 4 - Maintain Alliance AuthRun migrationspython manage.py migrateGather your staticfilespython manage.py collectstaticRestart your projectsupervisorctl restart myauth:Step 5 - Pre-Load Django-EveUniversepython manage.py eveuniverse_load_data mapThis will load Regions, Constellations and Solar SystemsContributingMake 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.

aaindex

Python package for working with the AAindex database (https://www.genome.jp/aaindex/)Table of ContentsIntroductionRequirementsInstallationUsageTestsContactLicenseReferencesIntroductionThe AAindex is a database of numerical indices representing various physicochemical, structural and biochemical properties of amino acids and pairs of amino acids 🧬. The AAindex consists of three sections: AAindex1 for the amino acid index of 20 numerical values, AAindex2 for the amino acid mutation matrix and AAindex3 for the statistical protein contact potentials. All data are derived from published literature[1].ThisaaindexPython software package is a very lightweight way of accessing the data represented in the various AAindex databases, requiring no additional external library installations. Any record within the 3 databases and their associated data/numerical indices can be accessed in one simple command. Currently the software supports the AAindex1 database with plans to include the AAindex 2 & 3 in the future.A demo of the software is availablehere.InstallationInstall the latest version ofaaindexusing pip:pip3installaaindex--upgradeInstall by cloning the repository:gitclonehttps://github.com/amckenna41/aaindex.git python3setup.pyinstallUsageTheaaindexpackage is made up of three modules for each AAindex database, with each having a Python class of the same name, when importing the package you should import the required database module:fromaaindeximportaaindex1# from aaindex import aaindex2# from aaindex import aaindex3AAIndex1 UsageGet record from AAindex1The AAindex1 class offers diverse functionalities for obtaining any element from any record in the database. The records are imported from a parsed json in the data folder of the package. You can search for a particular record by its record code/accession number or its name/description. You can also get the record category, references, notes, correlation coefficients, PMID and importantly its associated amino acid values:fromaaindeximportaaindex1full_record=aaindex1['CHOP780206']#get full AAI record''' full_record ->{'category': 'sec_struct', 'correlation_coefficients': {},'description': 'Normalized frequency of N-terminal non helical region (Chou-Fasman, 1978b)', 'notes': '', 'pmid': '364941','references': "Chou, P.Y. and Fasman, G.D. 'Prediction of the secondary structure of proteins from their amino acid sequence' Adv. Enzymol. 47, 45-148 (1978)", 'values': {'-': 0, 'A': 0.7, 'C': 0.65, 'D': 0.98, 'E': 1.04, 'F': 0.93, 'G': 1.41, 'H': 1.22, 'I': 0.78, 'K': 1.01, 'L': 0.85, 'M': 0.83, 'N': 1.42, 'P': 1.1, 'Q': 0.75, 'R': 0.34, 'S': 1.55, 'T': 1.09, 'V': 0.75, 'W': 0.62, 'Y': 0.99}}'''#get individual elements of AAindex recordrecord_values=aaindex1['CHOP780206']['values']record_values=aaindex1['CHOP780206'].values#'values': {'-': 0, 'A': 0.7, 'C': 0.65, 'D': 0.98, 'E': 1.04, 'F': 0.93, 'G': 1.41, 'H': 1.22, 'I': 0.78, 'K': 1.01, 'L': 0.85, 'M': 0.83, 'N': 1.42, 'P': 1.1, 'Q': 0.75, 'R': 0.34, 'S': 1.55, 'T': 1.09, 'V': 0.75, 'W': 0.62, 'Y': 0.99}record_description=aaindex1['CHOP780206']['description']record_description=aaindex1['CHOP780206'].description#'description': 'Normalized frequency of N-terminal non helical region (Chou-Fasman, 1978b)'record_references=aaindex1['CHOP780206']['references']record_references=aaindex1['CHOP780206'].references#'references': "Chou, P.Y. and Fasman, G.D. 'Prediction of the secondary structure of proteins from their amino acid sequence' Adv. Enzymol. 47, 45-148 (1978)"record_notes=aaindex1['CHOP780206']['notes']record_notes=aaindex1['CHOP780206'].notes#""record_correlation_coefficient=aaindex1['CHOP780206']['correlation_coefficient']record_correlation_coefficient=aaindex1['CHOP780206'].correlation_coefficient#{}record_pmid=aaindex1['CHOP780206']['pmid']record_pmid=aaindex1['CHOP780206'].pmid#364941record_category=aaindex1['CHOP780206']['category']record_category=aaindex1['CHOP780206'].category#sec_structGet total number of AAindex1 recordsaaindex1.num_records()Get list of all AAindex1 record codesaaindex1.record_codes()Get list of all AAindex1 record namesaaindex1.record_names()AAIndex2 Usage# from aaindex import aaindex1fromaaindeximportaaindex2# from aaindex import aaindex3AAIndex3 Usage# from aaindex import aaindex1# from aaindex import aaindex2fromaaindeximportaaindex3Directories 📁/tests- unit and integration tests foraaindexpackage./aaindex- source code and all required external data files for package./images- images used throughout README./docs-aaindexdocumentation.Tests 🧪To run all tests, from the mainaaindexfolder run:python3 -m unittest discover testsContact ✉️If you have any questions or comments, please contactamckenna41@qub.ac.ukor raise an issue on theIssuestab.LicenseDistributed under the MIT License. SeeLICENSEfor more details.References[1]: Shuichi Kawashima, Minoru Kanehisa, AAindex: Amino Acid index database, Nucleic Acids Research, Volume 28, Issue 1, 1 January 2000, Page 374,https://doi.org/10.1093/nar/28.1.374[2]:https://www.genome.jp/aaindex/Back to top

aaindexer

No description available on PyPI.

aa-industry

Industry plugin app for Alliance AuthThis is an Industry plugin app forAlliance Auth(AA) that can be used as starting point to develop custom plugins.InstallationRun the pip command to install$pipinstallaa-industryadd theindustryapp to settings.py underINSTALLED_APPSrun the migrations and collect static commands$pythonmanage.pymigrate $pythonmanage.pycollectstaticUpdatingRun the pip command to install$pipinstall-Uaa-industryor$pipinstall--upgradeaa-industryrun the migrations and collect static commands$pythonmanage.pymigrate $pythonmanage.pycollectstaticPermissionsTo make it visible to users or groups you must provide theindustry.view_industrypermission.ScopesThe scopes required to see the industry jobs for the character and corporations are:ScopePermissionesi-industry.read_character_jobs.v1Read Character Jobsesi-industry.read_corporation_jobs.v1Read Corporation Jobsesi-universe.read_structures.v1Read Structure information (to retrieve the names)ContributeIf you made a new app for AA please consider sharing it with the rest of the community. For any questions on how to share your app please contact the AA devs on their Discord. You find the current community creationshere.

aa-intel-tool

AA Intel ToolD-Scans and more inAlliance Auth.AA Intel ToolOverviewFeaturesScreenshotsChat ScanD-ScanFleet CompositionInstallationStep 1: Install the PackageStep 2: Configure Alliance AuthAdd the App to Alliance AuthAdd the Scheduled Task(Optional) Allow Public ViewsStep 4: Preload Eve Universe DataStep 5: Finalizing the InstallationStep 6: Update Your Webserver ConfigurationApache 2NginxSettingsChangelogTranslation StatusContributingNoteThis 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.OverviewFeaturesThe following modules can be enabled or disabled. SeeSettingssection for details.Chat scan module (Disabled by default due to its possible high number of ESI calls)D-Scan moduleScreenshotsChat ScanD-ScanFleet CompositionInstallationNotePlease make sure you meet all preconditions before you proceed:AA Intel Tool is a plugin forAlliance Auth. If you don't have Alliance Auth running already, please install it first before proceeding. (see the officialAlliance Auth installation guidefor details)AA Intel Tool needs at leastAlliance Auth v3.6.1. Please make sure to meet this conditionbeforeinstalling this app, otherwise an update to Alliance Auth will be pulled in unsupervised.AA Intel Tool needsEve Universeto function. Please make sure it is installed, before continuing.Step 1: Install the PackageMake sure you're in the virtual environment (venv) of your Alliance Auth installation Then install the latest release directly from PyPi.pipinstallaa-intel-toolStep 2: Configure Alliance AuthAdd the App to Alliance AuthThis is fairly simple, configure your AA settings (local.py) as follows:Addeveuniverse(if not already done so for a different app) andaa_intel_toolto the list ofINSTALLED_APPS.# Add any additional apps to this list.INSTALLED_APPS+=["eveuniverse","aa_intel_tool",# https://github.com/ppfeufer/aa-intel-tool]Add the Scheduled TaskTo remove old scans from your DB, add the following task. The retention time can be adjusted through theINTELTOOL_SCAN_RETENTION_TIMEsetting.if"aa_intel_tool"inINSTALLED_APPS:# Run at 01:00 each dayCELERYBEAT_SCHEDULE["AA Intel Tool :: Housekeeping"]={"task":"aa_intel_tool.tasks.housekeeping","schedule":crontab(minute="0",hour="1"),}(Optional) Allow Public ViewsThis app supports AA's feature of public views. To allow this feature, please add"aa_intel_tool",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=["aa_intel_tool",# https://github.com/ppfeufer/aa-intel-tool]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.Step 4: Preload Eve Universe DataAA Intel Tool utilizes the EveUniverse module, so it doesn't need to ask ESI for ship information. To set this up, you now need to run the following command.pythonmanage.pyaa_intel_tool_load_eve_typesStep 5: Finalizing the InstallationRun static files collection and migrations.pythonmanage.pycollectstatic pythonmanage.pymigrateRestart your supervisor services for Auth.Step 6: Update Your Webserver ConfigurationBy default, webservers have a timout of about 30 seconds for requests. So we have to tweak that a little bit, since parsing intel data can take a while, and we don't want the webserver to spoil our fun, right?Apache 2Open your vhost configuration and add the following 2 lines right after theProxyPreserveHost Ondirective:ProxyTimeout600Timeout600Restart your Apache2 service.NginxOpen your vhost configuration and add the following lines inside thelocation / {directive:proxy_connect_timeout600;proxy_read_timeout600;proxy_send_timeout600;send_timeout600;Restart your Nginx service.SettingsTo customize the app, the following settings are available and can be made in yourlocal.py.WarningEnable the chat scan module at your own risk. This module has the potential to generate a huge number of ESI calls, which CCP might not be too happy about.NameDescriptionDefaultINTELTOOL_ENABLE_MODULE_CHATSCANEnable or disable the chat scan module.FalseINTELTOOL_ENABLE_MODULE_DSCANEnable or disable the d-scan module.TrueINTELTOOL_ENABLE_MODULE_FLEETCOMPEnable or disable the fleet composition module.TrueINTELTOOL_SCAN_RETENTION_TIMESet the time in days for how long the scans will be kept in the database. Set to 0 to keep scans indefinitely.30INTELTOOL_CHATSCAN_MAX_PILOTSSet the limit of pilots for chat scans, since these can take quite a long time to process. Set to 0 to disable.500INTELTOOL_DSCAN_GRID_SIZESet the grid size for D-Scans. This definesthe size of the grid in km in which ships and structures are considered to be "on grid"10000NoteA word about the chat scan limitations:It is advised to keep theINTELTOOL_CHATSCAN_MAX_PILOTSto a sane number. Large chat scans can take quite some time to parse and from a certain number of pilots, the bottleneck might be your browser refusing to render the results page. (Source: Trust me, bro …)ChangelogSeeCHANGELOG.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)

aa-intercom

Django integration forIntercomAPITheaa-intercompackage allows toupload user data to Intercom including the last seen featurepush data to the Intercom API according to any event happening in your appInstallationTo use, addaa_intercomto yourINSTALLED_APPS, and then migrate the project.Setting up modelsaa-intercomrequires a few fields in the user model to be set. To make it work, you need to apply theaa_intercom.mixins.IntercomUserMixinto your custom user model (if you do not have your own custom user model set, check thedocumentation). TheIntercomUserMixin.get_intercom_data()method can be overloaded to change the default user data sent to the Intercom API.If you want to use the user last seen feature on Intercom, execute the following task right after the user logs in:from aa_intercom.tasks import push_account_last_seen_tasks push_account_last_seen_task.apply_async(args=[user.id], countdown=100)ConfigurationAnother step is to add event types to project settings, for example:INTERCOM_EVENT_TYPES = ( ("example", _("Example Type")), ("generic", _("Generic Type")) )The last thing is to specify Intercom credentials in project settings:INTERCOM_API_ACCESS_TOKEN = "your access token"Make sure, you have theCACHESset (see:docs), and also as this app usesCelery, you need to have it configured.To provide id prefix for Intercom user id, setINTERCOM_ID_PREFIXto desired value.Using the IntercomEvent modelIf you want to send any kind of event data to the Intercom API, create an instance ofIntercomEventfilled with desired information, for example:IntercomEvent.objects.create( user=request.user, type="generic", text_content=post.content, content_type=ContentType.objects.get_for_model(Post), object_id=post.id)Then it will be automatically sent to the Intercom API. Unfortunately Intercom API has a tendency to go down often, therefore to make sure all events will be sent, setup a cronjob running theresend_intercom_eventscommand which will push all remaining IntercomEvent objects to the API.Sending unregistered user dataIn case an upload of unregistered user data is needed, theaa_intercom.tasks.push_not_registered_user_data_tasktask can be used (emailandnamekeys are required), for example:push_not_registered_user_data_task.apply_async(args=[{ "email": "test@arabel.la", "name": "Foo Bar", "pseudonym": "foobar" }])Commandsresend_intercom_events- resends all events (in case something went wrong, should be run chronically)SupportDjango 1.11Python 2.7, 3.6

aaio

AAIO API for Python 3AAIO Official documentationAboutThis library is a wrapper for thehttps://aaio.soAPIfrom enthusiasts. All methods are described and all types areexplicitlydefined. Methods that create requests to aaio.so return a pydantic's models for each response. Please write about all problems related to the library toissuesAPI is up-to-date as of19 December 2023.PyPl -https://pypi.org/project/aaio/Github -https://github.com/kewldan/AAIODocs -https://kewldan.vercel.app/projects/aaioDemo -https://t.me/aaio_demo_botRequirements: Python >= 3.7Added toAAIO SDKsFeaturesIt's completelyasynchronousYou can usemultipleclients to work withmultipleusers or shopsAll methodsfor working with API are implementedThe library returns strictly typed for responses from APIsFor each method,docstringsare usedThe library handle {type: error} responses and throws AAIOBadRequest exceptionOur library was thefirstto be added to theofficialAAIO wikiModern, strict code for Python 3.7Library InstallationInstall via pip:pip install aaioDownload sources -git clone https://github.com/kewldan/AAIOGetting StartedGet user balanceimportasynciofromaaioimportAAIOasyncdefmain():client=AAIO('MERCHANT ID','SECRET KEY','API KEY')balances=awaitclient.get_balances()print(balances)# type='success' code=None message=None balance=625.85 referral=172.96 hold=0.0asyncio.run(main())Create payment URL for customerimportasynciofromaaioimportAAIOasyncdefmain():client=AAIO('MERCHANT ID','SECRET KEY','API KEY')payment_url=client.create_payment(100,'my_order_id','My order description','qiwi','support@aaio.so','referral code',currency='USD',language='en')print(payment_url)# Prints payment url for customerasyncio.run(main())Create payoffimportasynciofromaaioimportAAIOasyncdefmain():client=AAIO('MERCHANT ID','SECRET KEY','API KEY')payoff=awaitclient.create_payoff('qiwi',100.35,'79998887766','my_payoff_id')print(payoff.status)# in_progressasyncio.run(main())ContactE-Mail -kewldanil1@gmail.comTelegram -@kewldanLicenseReleased underMITby@kewldan.

aaiopay

Installation | УстановкаWindowspip install aaiopayLinuxpip3 install aaiopayInformation | ИнформацияENG: The current version of AaioPay is 0.2.4 RU: Актуальная версия AaioPay 0.2.4Methods | ФyнкцииENGAsynchronous module for working with the Aaio API What can? - Getting a balance - Creating a payment form - Getting up-to-date transactionsRUАсинхронный модуль для работы с API Aaio Что может? - Получение баланса - Создание формы оплаты - Получение актуальных транзакций

aaiotrello

Python Trello API WrapperThis Python API is simply a wrapper around the Trello APIGetting Started:To use the Trello API, install the package either by downloading the source and running$ python setup.py installDocumentation:You can find documentation for the Python API at:http://packages.python.org/trello/And documentation for the Trello API at:https://trello.com/docs/api/

aajna

ajnaA library for mechanistic interpretability.

aakashdist

No description available on PyPI.

aakbar

Amino-Acid k-mer tools for creating, searching, and analyzing phylogenetic signatures from genomes or reads of DNA.PrerequisitesA 64-bit Python 3.4 or greater is required. 8 GB or more of memory is recommended.The python dependencies of aakbar are: biopython, click>=5.0, click_plugins numpy, pandas, pyfaidx, and pyyaml. Running the examples also requires thepyfastaq https://pypi.python.org/pypi/pyfastaqpackage.If you don’t have a python installed that meets these requirements, I recommend gettingAnaconda Python <https://www.continuum.io/downloads>on MacOSX and Windows for the smoothness of installation and for the packages that come pre-installed. Once Anaconda python is installed, you can get the dependencies like this on MacOSX:export PATH=~/anaconda/bin:${PATH} # you might want to put this in your .profile conda install click conda install --channel https://conda.anaconda.org/IOOS click-plugins conda install --channel https://conda.anaconda.org/bioconda pyfaidx conda install --channel https://conda.anaconda.org/bioconda pyfastaqInstallationThis package is tested under Linux and MacOS using Python 3.5 and is available from the PyPI. To install via pip (or pip3 under some distributions) :pip install aakbarIf you wish to develop aakbar, download areleaseand in the top-level directory:pip install --editable .If you wish to have pip install directly from git, use this command:pip install git+https://github.com/ncgr/aakbar.gitUsageInstallation puts a single script calledaakbarin your path. The usage format is:aakbar [GLOBALOPTIONS] COMMAND [COMMANDOPTIONS] [ARGS]A listing of commands is available viaaakbar--help. Current available commands are:calculate-peptide-termsWrite peptide terms and histograms.conserved-signature-statsStats on signatures found in all input genomes.define-setDefine an identifier and directory for a set.define-summaryDefine summary directory and label.demo-simplicityDemo self-provided simplicity outputs.filter-peptide-termsRemove high-simplicity terms.init-config-fileInitialize a configuration file.install-demo-scriptsCopy demo scripts to the current directory.intersect-peptide-termsFind intersecting terms from multiple sets.label-setDefine label associated with a set.peptide-simplicity-maskLower-case high-simplicity regions in FASTA.search-peptide-occurrancesFind signatures in peptide space.set-simplicity-windowDefine size of window used in simplicity calcs.set-plot-typeDefine label associated with a set.set-simplicity-typeSelect function used in simplicity calculation.show-configPrint location and contents of config file.show-context-objectPrint the global context object.test-loggingLogs at different severity levels.ExamplesBash scripts that implement examples for calculating and using signature sets for Firmicutes and Streptococcus, complete with downloading data from GenBank, will be created in the (empty) current working directory when you issue the command:aakbar install-demo-scriptsOn linux and MacOS, follow the instructions to run the demos. On Windows, you will needbashinstalled for the scripts to work.ToolsIn addition to pyfastaq, two tools that you will probably find helpful in working with aakbar arealphabetsoup <https://github.com/ncgr/alphabetsoup>for sanitizing input FASTA files andtsv-tools <https://https://github.com/eBay/tsv-utils/>for filtering output TSV files.Latest ReleaseGitHubLicenseDocumentationTravis BuildCoverageCode GradeDependenciesIssues

aaki

No description available on PyPI.

aa-killtracker

KilltrackerAn app for running killmail trackers with Alliance Auth and Discord.ContentsOverviewKey FeaturesScreenshotsInstallationTrackersSettingsChange LogOverviewKilltracker is an app for running killmail based trackers with Alliance Auth and Discord. Trackers are small programs that automatically select killmails based on a set of pre-defined conditions and then post them to a Discord channel as soon as they appear on zKillboard.The main advantage of the Killtracker app over similar apps is it's high customizability, which allows you to cut through the noise of many false positives and only get the results you are really interested in.For example you may want to know when a larger group is roaming through your area? Set up a tracker that shows all kills within 10 jumps of your staging that has more than 20 attackers. It will even ping you if you want.Or you maybe want to be informed about any capitals being active within your jump range? Just setup a tracker for capital kills within 6 LY of your staging.Key FeaturesAutomatically post killmails conforming with a set of conditions to a Discord channel as soon as they arrive on zKillboardUse 20+ clauses to define exactly what you want to track incl. clauses for location, organization, Auth state and ship typesClauses for "ship types" include ships, structures, customs offices, fighters and excavator dronesOptional channel and group pinging for matching killmailsDesigned for fast response times, high throughput and low resource requirementsGet additional insights about killmails like distance from stagingSee which fleets / groups are active in your area of interestCustomize killmail messages with titles and colorsScreenshotsHere is an example for settings up a new tracker:And here is how posted killmails look on Discord:InstallationStep 1 - Check preconditionsKilltracker 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)Killtracker needs the appdjango-eveuniverseto function. Please make sure it is installed, before continuing.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-killtrackerStep 3 - Configure settingsConfigure your AA settings (local.py) as follows:Installed appsAdd'killtracker'toINSTALLED_APPS.Killtracker configurationAdd below lines to your settings file:# aa-killtrackerCELERYBEAT_SCHEDULE['killtracker_run_killtracker']={'task':'killtracker.tasks.run_killtracker','schedule':crontab(minute='*/1'),}KILLTRACKER_QUEUE_ID=""# Put your unique queue ID hereQueue IDPlease note that the queue ID must be globally unique for all users of the zKillboard API, so choose carefully.We suggest to use your alliance name or alliance tag (without any spaces and special characters) as queue ID.We recommend using only characters (upper and lower case) and numbers, but no spaces or any special characters when choosing your ID.Example (don't use this exact example):KILLTRACKER_QUEUE_ID="Voltron9000"If you are running multiple instances of Killtracker please choose a different queue ID for each of them.Additional settings (optional)Add additional settings if you want to change any defaults. SeeSettingsfor the full list.Step 4 - Finalize installationRun migrations & copy static filespythonmanage.pymigrate pythonmanage.pycollectstaticRestart your supervisor services for AuthStep 5 - Load Eve Universe map dataIn order to be able to select solar systems and types for trackers you need to load that data from ESI once.Load Eve Online map: (If you already have run this command with another app you can skip this step)pythonmanage.pyeveuniverse_load_datamapLoad app specific types:pythonmanage.pykilltracker_load_eveYou may want to wait until the loading is complete before starting to create new trackers.Step 6 - Setup trackersThe setup and configuration for trackers is done on the admin page underKilltracker.First need to add the Discord webhook that points to the channel you want your killmail to appear toWebhooks. You can use one webhook for all trackers, but it is usually better to create a new channel / webhook for each tracker.To test that your webhook works correctly you can send a test notification.Next you can create your trackers underTracker. Make sure you link each tracker to the right webhook. Once you save a tracker that isenabledit will start working.As final test that your setup is correct you may want to create a "Catch all" tracker. for that just create a new tracker without any conditions and it will forward all killmails to your Discord channel as they are received.Congratulations you are now ready to use killtracker!TrackersAll trackers are setup and configured on the admin site underKilltracker.Each tracker has a name, is linked to a webhook and has a set of conditions that define which killmails are selected and shown in the Discord channel. Note that if you define a tracker without any conditions tan you got a "catch all" tracker, that will post any killmail on Discord.Each of the 20+ conditions belongs to one of two categories and they are named accordingly:require: Require conditions must be fulfilled by a killmail. e.g. a tracker with the conditionrequire min attackers = 10will post only killmails on Discord that have at least 10 attackers.exclude: Exclude conditions are the opposite of require. Killmails that fulfil this condition will never be posted by this tracker. e.g. a tracker withexclude high secwill never show any killmails from high sec.You can combine multiple conditions to create the tracker you want. Note that conditions are always combined together with a boolean AND. For example: if your tracker hasrequire min attackersset to 10 andexclude high secenabled, then you will only get killmails that both have at least 10 attackers and are not in high sec.Here is a list of all currently supported conditions for each tracker:NameDescriptionrequire max jumpsRequire all killmails to be max x jumps away from origin solar systemrequire max distanceRequire all killmails to be max x LY away from origin solar systemrequire min attackersRequire killmails to have at least given number of attackersrequire max attackersRequire killmails to have no more than max number of attackersexclude high secexclude killmails from high sec. Also exclude high sec systems in route finder for jumps from origin.exclude low secexclude killmails from low secexclude null secexclude killmails from null secexclude w spaceexclude killmails from WH spacerequire min valueRequire killmail's value to be greater or equal to the given value in M ISKexclude npc killsexclude npc killsrequire npc killsonly include killmails that are npc killsexclude attacker alliancesexclude killmails with attackers from one of these alliancesexclude attacker corporationsexclude killmails with attackers from one of these corporationsrequire attacker alliancesonly include killmails with attackers from one of these alliancesrequire attacker corporationsonly include killmails with attackers from one of these corporationsrequire victim alliancesonly include killmails where the victim belongs to one of these alliancesrequire victim corporationsonly include killmails where the victim belongs to one of these corporationsexclude_attacker_statesexclude killmails with characters belonging to users with these Auth statesrequire_attacker_statesonly include killmails with characters belonging to users with these Auth statesrequire_victim_statesonly include killmails where the victim characters belong to users with these Auth staterequire regionsOnly include killmails that occurred in one of these regionsrequire constellationsOnly include killmails that occurred in one of these regionsrequire solar systemsOnly include killmails that occurred in one of these regionsrequire attackers ship groupsOnly include killmails where at least one attacker is flying one of these ship groupsrequire attackers ship typesOnly include killmails where at least one attacker is flying one of these ship typesrequire victim ship groupsOnly include killmails where victim is flying one of these ship groupsrequire victim ship typesOnly include killmails where victim is flying one of these ship typesSettingsHere 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.NameDescriptionDefaultKILLTRACKER_KILLMAIL_MAX_AGE_FOR_TRACKERIgnore killmails that are older than the given number in minutes. Sometimes killmails appear belated on ZKB, this feature ensures they don't create new alerts60KILLTRACKER_MAX_KILLMAILS_PER_RUNMaximum number of killmails retrieved from ZKB by task run. This value should be set such that the task that fetches new killmails from ZKB every minute will reliable finish within one minute. To test this run a "Catch all" tracker and see how many killmails your system is capable of processing. Note that you can get that information from the worker's log file. It will look something like this:Total killmails received from ZKB in 49 secs: 251250KILLTRACKER_PURGE_KILLMAILS_AFTER_DAYSKillmails older than set number of days will be purged from the database. If you want to keep all killmails set this to 0. Note that this setting is only relevant if you have storing killmails enabled.30KILLTRACKER_QUEUE_IDUnique ID used to identify this server when fetching killmails from zKillboard. This setting is mandatory.``KILLTRACKER_STORING_KILLMAILS_ENABLEDIf set to true Killtracker will automatically store all received killmails in the local database. This can be useful if you want to run analytics on killmails etc. However, please note that Killtracker itself currently does not use stored killmails in any way.FalseKILLTRACKER_WEBHOOK_SET_AVATARWether app sets the name and avatar icon of a webhook. When False the webhook will use it's own values as set on the platformTrue

aakr

aakr (Auto Associative Kernel Regression)aakris a Python implementation of the Auto-Associative Kernel Regression (AAKR). The algorithm is suitable for signal reconstruction, which can further be used for condition monitoring, anomaly detection etc.Documentation is available athttps://aakr.readthedocs.io.Installationpip install aakrQuickstartGiven historical normal conditionX_ncexamples and new observationsX_obsof sizen_samples x n_features, what values we expect to see in normal conditions for the new observations?fromaakrimportAAKR# Create AAKR modelaakr=AAKR()# Fit the model with normal condition examplesaakr.fit(X_nc)# Ask for values expected to be seen in normal conditionsX_obs_nc=aakr.transform(X_obs)ReferencesAssessment of Statistical and Classification Models For Monitoring EDF’s AssetsA modified Auto Associative Kernel Regression method for robust signal reconstruction in nuclear power plant componentsJesse Myrberg (jesse.myrberg@gmail.com)

aa-krab

FittingsA wormhole krab fleet management and tracking app forallianceauth.ContentsOverviewKey FeaturesScreenshotsInstallationUpdatingSettingsPermissionsOverviewThis app provides a method of tracking krab fleet member contributions and payouts.Key FeaturesAA-Krab offers the following features:Scheduling of krab fleetsFleet registration and position selectionPayout TrackingScreenshotsInstallation1. Install AppInstall the app into your allianceauth virtual environment via PIP.$pipinstallaa-krab2. Configure AA settingsConfigure your AA settings (local.py) as follows:Add'fittings',toINSTALLED_APPS3. Finalize InstallRun migrations and copy static files.$pythonmanage.pymigrate $pythonmanage.pycollectstaticRestart your supervisor tasks.UpdatingTo update your existing installation of AA-Krab first enable your virtual environment.Then run the following commands from your allianceauth project directory (the one that containsmanage.py).$pipinstall-Uaa-krab $pythonmanage.pymigrate $pythonmanage.pycollectstaticLastly, restart your supervisor tasks.Note: Be sure to follow any version specific update instructions as well. These instructions can be found on theTagspage for this repository.SettingsSettingDefaultDescriptionNo settings-There are no settings right nowPermissionsPermissionDescriptionaakrab.basic_accessThis permission gives users access to the app.Active DevelopersBelial Morningstar

aalam-common

No description available on PyPI.

aalink

aalink is a Python wrapper for Ableton Link built for interactive applications using asyncio event loops.It provides awaitable objects for synchronizing Python code with other peers in an Ableton Link session, but it may also be used for writing fully standalone scripts with tempo/beat synchronization, such as applications for light and sound control.Installationaalink requires at least Python 3.8. It can be installed using pip:pip3 install aalinkIt may be required to install the latest version of MSVC Runtime libraries on Windows to use the binary wheels currently hosted on PyPI.Usageaalink uses asyncio. To connect to a Link session, create aLinkobject, passing the asyncio event loop to the constructor, and await forLink.sync()as follows:importasynciofromaalinkimportLinkasyncdefmain():loop=asyncio.get_running_loop()link=Link(120,loop)link.enabled=TruewhileTrue:awaitlink.sync(1)print('bang!')asyncio.run(main())Link.sync(n)returns aFuturescheduled to bedonewhen Link time reaches next n-th beat on the timeline.In the above example, awaiting forlink.sync(1)will pause and resume themaincoroutine at beats 1, 2, 3, and so on.Keep in mind that awaiting forsync(n)does not cause a coroutine to sleep for the given number of beats. Regardless of the moment when the coroutine is suspended, it will resume when the next closest n-th beat is reached on the shared Link timeline, e.g. awaiting forsync(2)at beat 11.5 will resume at beat 12.Non-integral beat syncing is supported. For example:awaitlink.sync(1/2)# resumes at beats 0.5, 1, 1.5...awaitlink.sync(3/2)# resumes at beats 1.5, 3, 4.5...Sync events can be scheduled with an offset (also expressed in beats) by passing anoffsetargument tosync(). Use this to add groove to the coroutine rhythm.asyncdefarpeggiate():foriinrange(16):swing=0.25ifi%2==1else0awaitlink.sync(1/2,offset=swing)print('###',i)awaitlink.sync(1/2,offset=0)print('@@@',i)Combine synced coroutines to run in series or concurrently:importasynciofromaalinkimportLinkasyncdefmain():loop=asyncio.get_running_loop()link=Link(120,loop)link.enabled=Trueasyncdefsequence(name):foriinrange(4):awaitlink.sync(1)print('bang!',name)awaitsequence('a')awaitsequence('b')awaitasyncio.gather(sequence('c'),sequence('d'))asyncio.run(main())Limitationsaalink aims to be punctual, but it is not 100% accurate due to the processing delay in the internal scheduler and the uncertainty of event loop iterations timing.For convenience, the numerical values of futures returned fromsync()aren’t equal to the exact beat time from the moment the futures aredone. They correspond to the previously estimated resume times instead.b=awaitlink.sync(1)# b will be 1.0, returned at beat 1.00190b=awaitlink.sync(1)# b will be 2.0, returned at beat 2.00027b=awaitlink.sync(1)# b will be 3.0, returned at beat 3.00005LicenseCopyright (c) 2023 Artem Popov <art@artfwo.net>aalink is licensed under the GNU General Public License (GPL) version 3. You can find the full text of the GPL license in theLICENSEfile included in this repository.aalink includes code from pybind11 and Ableton Link.pybind11Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>, All rights reserved.pybind11 licenseAbleton LinkCopyright 2016, Ableton AG, Berlin. All rights reserved.Ableton Link license

aalink-aarch64

aalink is a Python wrapper for Ableton Link built for interactive applications using asyncio event loops.It provides awaitable objects for synchronizing Python code with other peers in an Ableton Link session, but it may also be used for writing fully standalone scripts with tempo/beat synchronization, such as applications for light and sound control.Installationaalink requires at least Python 3.8. It can be installed using pip:pip3 install aalink-aarch64It may be required to install the latest version of MSVC Runtime libraries on Windows to use the binary wheels currently hosted on PyPI.Usageaalink uses asyncio. To connect to a Link session, create aLinkobject, passing the asyncio event loop to the constructor, and await forLink.sync()as follows:importasynciofromaalink_aarch64importLinkasyncdefmain():loop=asyncio.get_running_loop()link=Link(120,loop)link.enabled=TruewhileTrue:awaitlink.sync(1)print('bang!')asyncio.run(main())Link.sync(n)returns aFuturescheduled to bedonewhen Link time reaches next n-th beat on the timeline.In the above example, awaiting forlink.sync(1)will pause and resume themaincoroutine at beats 1, 2, 3, and so on.Keep in mind that awaiting forsync(n)does not cause a coroutine to sleep for the given number of beats. Regardless of the moment when the coroutine is suspended, it will resume when the next closest n-th beat is reached on the shared Link timeline, e.g. awaiting forsync(2)at beat 11.5 will resume at beat 12.Non-integral beat syncing is supported. For example:awaitlink.sync(1/2)# resumes at beats 0.5, 1, 1.5...awaitlink.sync(3/2)# resumes at beats 1.5, 3, 4.5...Sync events can be scheduled with an offset (also expressed in beats) by passing anoffsetargument tosync(). Use this to add groove to the coroutine rhythm.asyncdefarpeggiate():foriinrange(16):swing=0.25ifi%2==1else0awaitlink.sync(1/2,offset=swing)print('###',i)awaitlink.sync(1/2,offset=0)print('@@@',i)Combine synced coroutines to run in series or concurrently:importasynciofromaalinkimportLinkasyncdefmain():loop=asyncio.get_running_loop()link=Link(120,loop)link.enabled=Trueasyncdefsequence(name):foriinrange(4):awaitlink.sync(1)print('bang!',name)awaitsequence('a')awaitsequence('b')awaitasyncio.gather(sequence('c'),sequence('d'))asyncio.run(main())Limitationsaalink aims to be punctual, but it is not 100% accurate due to the processing delay in the internal scheduler and the uncertainty of event loop iterations timing.For convenience, the numerical values of futures returned fromsync()aren’t equal to the exact beat time from the moment the futures aredone. They correspond to the previously estimated resume times instead.b=awaitlink.sync(1)# b will be 1.0, returned at beat 1.00190b=awaitlink.sync(1)# b will be 2.0, returned at beat 2.00027b=awaitlink.sync(1)# b will be 3.0, returned at beat 3.00005LicenseCopyright (c) 2023 Artem Popov <art@artfwo.net>aalink is licensed under the GNU General Public License (GPL) version 3. You can find the full text of the GPL license in theLICENSEfile included in this repository.aalink includes code from pybind11 and Ableton Link.pybind11Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>, All rights reserved.pybind11 licenseAbleton LinkCopyright 2016, Ableton AG, Berlin. All rights reserved.Ableton Link license

aalpy

AALpyAn Active Automata Learning LibraryAALpy is a light-weight automata learning library written in Python. You can start learning automata in just a few lines of code.Whether you work with regular languages or you would like to learn models of (black-box) reactive systems, AALpy supports a wide range of modeling formalisms, includingdeterministic,non-deterministic, andstochastic automata, as well asdeterministic context-free grammars/pushdown automata.Automata TypeSupported FormalismsAlgorithmsFeaturesDeterministicDFAsMealy MachinesMoore MachinesL*KVRPNISeamless CachingCounterexample Processing13 Equivalence OraclesNon-DeterministicONFSMAbstracted ONFSML*ONFSMSize Reduction Trough AbstractionStochasticMarkov Decision ProcessesStochastic Mealy MachinesMarkov ChainsL*MDPL*SMMALERGIACounterexample ProcessingExportable to PRISM formatBindings to jALERGIAPushdownVPDA/SEVPAKVVPASpecification of exclusivecall-return pairsAALpy enables efficient learning by providing a large set of equivalence oracles, implementing various conformance testing strategies. Active learning is mostly based on Angluin'sL* algorithm, for which AALpy supports a selection of optimizations, including efficient counterexample processing caching. However, the recent addition of efficiently implementedKValgorithm requires (on average) much less interaction with the system under learning than L*. In addition, KV can be used to learn Visibly Deterministic Pushdown Automata (VPDA).AALpy also includespassive automata learning algorithms, namely RPNI for deterministic and ALERGIA for stochastic models. Unlike active algorithms which learn by interaction with the system, passive learning algorithms construct a model based on provided data.InstallationUse the package managerpipto install the latest release of AALpy:pipinstallaalpyTo install current version of the master branch (it might contain bugfixes and added functionalities between releases):pipinstallhttps://github.com/DES-Lab/AALpy/archive/master.zipThe minimum required version of Python is 3.6.Ensure that you haveGraphvizinstalled and added to your path if you want to visualize models.For manual installation, clone the repo and installpydot(the only dependency).Documentation and WikiIf you are interested in automata learning or would like to understand the automata learning process in more detail, please check out ourWiki. On Wiki, you will find more detailed examples on how to use AALpy.https://github.com/DES-Lab/AALpy/wikiExamples.pycontains many examples and it is a great starting point.UsageAll automata learning procedures follow this high-level approach:Define the input alphabet and system under learning (SUL)Choose the equivalence oracleRun the learning algorithmFor more detailed examples, check out:How to learn Regex with AALpyHow to learn MQTT with AALpyFew Simple ExamplesInteractive ExamplesExamples.pyExamples.pycontains examples covering almost the whole of AALpy's functionality, and it is a great starting point/reference.Wikihas a step-by-step guide to using AALpy and can help you understand AALpy and automata learning in general.Code snipped demonstrating some of AALpy's functionalitiesThe following snippet demonstrates a short example in which an automaton is eitherloadedorrandomly generatedand thenlearned.fromaalpy.utilsimportload_automaton_from_file,save_automaton_to_file,visualize_automaton,generate_random_dfafromaalpy.automataimportDfafromaalpy.SULsimportAutomatonSULfromaalpy.oraclesimportRandomWalkEqOraclefromaalpy.learning_algsimportrun_Lstar,run_KV# load an automaton# automaton = load_automaton_from_file('path_to_the_file.dot', automaton_type='dfa')# or construct it from state setupdfa_state_setup={'q0':(True,{'a':'q1','b':'q2'}),'q1':(False,{'a':'q0','b':'q3'}),'q2':(False,{'a':'q3','b':'q0'}),'q3':(False,{'a':'q2','b':'q1'})}small_dfa=Dfa.from_state_setup(dfa_state_setup)# or randomly generate onerandom_dfa=generate_random_dfa(alphabet=[1,2,3,4,5],num_states=20,num_accepting_states=8)big_random_dfa=generate_random_dfa(alphabet=[1,2,3,4,5],num_states=2000,num_accepting_states=500)# get input alphabet of the automatonalphabet=random_dfa.get_input_alphabet()# loaded or randomly generated automata are considered as BLACK-BOX that is queried# learning algorithm has no knowledge about its structure# create a SUL instance for the automaton/system under learningsul=AutomatonSUL(random_dfa)# define the equivalence oracleeq_oracle=RandomWalkEqOracle(alphabet,sul,num_steps=5000,reset_prob=0.09)# start learning# run_KV is for the most part reacquires much fewer interactions with the system under learninglearned_dfa=run_KV(alphabet,sul,eq_oracle,automaton_type='dfa')# or run L*# learned_dfa_lstar = run_Lstar(alphabet, sul, eq_oracle, automaton_type='dfa')# save automaton to file and visualize it# save_automaton_to_file(learned_dfa, path='Learned_Automaton', file_type='dot')# orlearned_dfa.save()# visualize automaton# visualize_automaton(learned_dfa)learned_dfa.visualize()# or just print its DOT representationprint(learned_dfa)To make experiments reproducible, define a random seed at the beginning of your program.fromrandomimportseedseed(2)# all experiments will be reproducibleSelected ApplicationsAALpy has been used to:Learn Bluetooth Low-EnergyLearn Input-Output Behavior of RNNsFind bugs in VIM text editorCite AALpy and Research ContactIf you use AALpy in your research, please cite us with of the following:Extended version (preferred)Tool paperIf you have research suggestions or you need specific help concerning your research, feel free to start adiscussionor contactedi.muskardin@silicon-austria.com. We are happy to help you and consult you in applying automata learning in various domains.ContributingPull requests are welcome. For significant changes, please open an issue first to discuss what you would like to change. In case of any questions or possible bugs, please open issues.

aalto-asr-preprocessor

FeaturesRule-based preprocessing recipes for ASRRecipes are validated with testsRequirementsPython >= 3.8ClickInstallationYou can installaalto-asr-preprocessorviapipfromPyPI:$pipinstallaalto-asr-preprocessorUsageFor detailed instructions, seeUsageor typeaalto-prep--helpin terminal.ContributingContributions are very welcome. To learn more, see theContributor Guide.LicenseDistributed under the terms of theMITlicense,Aalto ASR preprocessoris free and open source software.IssuesIf you encounter any problems, pleasefile an issuealong with a detailed description.CreditsThis project uses@cjolowicz’sHypermodern Python Cookiecuttertemplate.

aalto-boss

Bayesian Optimization Structure Search (BOSS) is a general-purpose Bayesian Optimization code. It is designed to facilitate machine learning in computational and experimental natural sciences.For a more detailed description of the code and tutorials, please consult theuser guide.InstallationBOSS is distributed as a PyPI package and can be installed using pip:python3 -m pip install aalto-bossWe recommend installing BOSS inside a virtual environment (venv,conda…). If you are not using virtual environments, we recommend performing a user-installation instead:python3 -m pip install --user aalto-bossBasic usageAs an easy example, consider the optimization of a bounded 1D function. BOSS can be run either directly from Python or via a CLI interface, both these approaches are illustrated briefly below. Note that BOSS always minimizes a given function.Python iterfaceTo run BOSS from Python we first define our objective function, by default BOSS expects this function to take a single 2D numpy array as argument (this behaviour can be modified) and return a scalar value. Next, we import theBOMainobject and feed it the function plus any number of BOSS keywords, after which the optimization can be started. Once finished, the optimziation results are returned in aBOResultsobject.""" Using BOSS to solve the minimization problem f(x) = sin(x) + 1.5*exp(-(x-4.3)**2) , 0 < x < 7 """importnumpyasnpfromboss.bo.bo_mainimportBOMainfromboss.pp.pp_mainimportPPMaindeffunc(X):""" BOSS-compatible definition of the function. """x=X[0,0]returnnp.sin(x)+1.5*np.exp(-(x-4.3)**2)if__name__=='__main__':bo=BOMain(func,np.array([[0.,7.]]),# boundskernel='rbf',initpts=5,iterpts=15,)res=bo.run()# print global minimum value and location from the last iterationprint(res.select('mu_glmin',-1),res.select('x_glmin',-1))# run BOSS post-processing# creates a folder "postprocessing" with plots and datapp=PPMain(res,pp_models=True,pp_acq_funcs=True)pp.run()Command-line iterfaceThe CLI is provided by an executable calledboss. The user must provide an input file containing a list of BOSS keywords and a separate Python script that defines a function to be optimized. By default, BOSS expects this function to take a single 2D numpy array as argument (this behaviour can be modified) and return a scalar value. Below we define such a function in a Python script, arbitrarily nameduser_function.py:""" user_function.py This script contains the function definition for the minimization problem f(x) = sin(x) + 1.5*exp(-(x-4.3)**2) , 0 < x < 7 Note that the bounds are specified in the BOSS input file. """importnumpyasnpdeffunc(X):""" BOSS-compatible definition of the function. """x=X[0,0]returnnp.sin(x)+1.5*np.exp(-(x-4.3)**2)To minimize this function subject to the constraint0 < x < 7, we define a BOSS input fileboss.in:# boss.inuserfnuser_function.pyfuncbounds07yrange-11kernelrbfinitpts5iterpts15The optimization (including post-processing) can now be started from the command line:$bossopboss.inCreditsBOSS is under active development in theMaterials Informatics Laboratoryat the University of Turku and theComputational Electronic Structure Theory (CEST) groupat Aalto University. Past and present members of development team includeVille ParkkinenHenri PaulamäkiArttu TolvanenUlpu RemesNuutti StenEmma LehtoTuomas RossiManuel KuchelmeisterMikael GranitRansell D’souzaArmi TiihonenMatthias StosiekJoakim Löfgren (maintainer)Milica Todorović (team lead)If you wish to use BOSS in your research, please citeMilica Todorovic, Micheal U. Gutmann, Jukka Corander, and Patrick RinkeBayesian inference of atomistic structure in functional materialsnpj Comput Mater5, 35 (2019)doi: 10.1038/s41524-019-0175-2Issues and feature requestsIt is strongly encouraged to submit bug reports, questions, and feature requests via thegitlab issue tracker. The BOSS development team can be contacted by email atmilica.todorovic@utu.fi

aalto-gpu

aalto-gpuAn extension designjobs to a kubernetes clusterThis extension is composed of a Python package namedaalto_gpufor the server extension and a NPM package namedaalto-gpufor the frontend extension.RequirementsJupyterLab >= 2.0InstallNote: You will need NodeJS to install the extension.pipinstallaalto_gpu jupyterlabbuildTroubleshootIf you are seeing the frontend extension but it is not working, check that the server extension is enabled:jupyterserverextensionlistIf the server extension is installed and enabled but you are not seeing the frontend, check the frontend is installed:jupyterlabextensionlistIf it is installed, try:jupyterlabclean jupyterlabbuildContributingInstallThejlpmcommand is JupyterLab's pinned version ofyarnthat is installed with JupyterLab. You may useyarnornpmin lieu ofjlpmbelow.# Clone the repo to your local environment# Move to aalto-gpu directory# Install server extensionpipinstall-e.# Register server extensionjupyterserverextensionenable--pyaalto_gpu--sys-prefix# Install dependenciesjlpm# Build Typescript sourcejlpmbuild# Link your development version of the extension with JupyterLabjupyterlabextensioninstall.# Rebuild Typescript source after making changesjlpmbuild# Rebuild JupyterLab after making any changesjupyterlabbuildYou can watch the source directory and run JupyterLab in watch mode to watch for changes in the extension's source and automatically rebuild the extension and application.# Watch the source directory in another terminal tabjlpmwatch# Run jupyterlab in watch mode in one terminal tabjupyterlab--watchNow every change will be built locally and bundled into JupyterLab. Be sure to refresh your browser page after saving file changes to reload the extension (note: you'll need to wait for webpack to finish, which can take 10s+ at times).Uninstallpipuninstallaalto_gpu jupyterlabextensionuninstallaalto-gpu

aaltopoiju

This is screen scraper for aaltopoiju.fi website. Please check terms and conditions before using.Installationpip install aaltopoiju

aam

All About "All about me"----------------Aam means "All about me". It is a lightweight about-me-site generator. To compare with a blog, Aam is for pages not posts. So you can use it to build your own resume page.Installation===============Requirements:* Jinja2* Mistune* Pygments* PargumentsInstall Aam with pip ::$ (sudo) pip install aamWith Git ::$ git clone git://github.com/JmPotato/Aam$ cd Aam$ (sudo) python setup.py installUsage===============First of all, creat a new site ::$ mkdir site$ cd site$ aam initThen, edit the config file ::$ vim config.iniYou need to have a home page befor a normal page. A home page should like this ::title: Welcomedate: 2014.7.1type: home----Weclome to Aam!A normal page named `Hello.md` ::title: Hello Worlddate: 2014.7.1description: The first pagetype: page----Hello, World!Generate the site ::$ aam buildNotice===============Every page file needs to include four metas.* title* date* description* typeIf you miss any one of them, the site won't be complete.

aa-mailrelay

MailrelayAn app for relaying Eve mails to Discord.ContentsOverviewInstallationSettingsChange LogOverviewThis app can automatically forwards eve mails to Discord channels. This can e.g. be useful to include people in all hands communications, who do not check their eve mails that often, but still can be reached via Discord.You can choose to just forward corporation or alliance mails only or all mails that a character receives.This app is an add-on toMember Auditand requires you to have Member Audit installed and running. You can choose to forward mails from any character that is registered on Member Audit.InstallationStep 1 - Check preconditionsPlease make sure you have the following applications installed and running before attempting to install the Mail Relay app:Alliance AuthAA Discord serviceMember AuditDiscord ProxyStep 2 - Install appMake sure you are in the virtual environment (venv) of your Alliance Auth installation. Then install the newest release from PyPI:pipinstallaa-mailrelayStep 3 - Configure settingsConfigure your Auth settings (local.py) as follows:Add'mailrelay'toINSTALLED_APPSAdd below lines to your settings file:CELERYBEAT_SCHEDULE['mailrelay_forward_new_mails']={'task':'mailrelay.tasks.forward_new_mails','schedule':crontab(minute='*/5'),}Optional: Add additional settings if you want to change any defaults. SeeSettingsfor the full list.Step 4 - Finalize installationRun migrations & copy static filespythonmanage.pymigrate pythonmanage.pycollectstaticRestart your supervisor services for Auth...Step 5 - Setup mail relaysTo setup your first mail relay go to the admin site / Mail Relay / RelayConfig.Update the known Discord channels by clicking the button: "UPDATE DISCORD CHANNELS".Click on "ADD RELAY CONFIG" to create your first mail relay configuration.SettingsHere 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.NameDescriptionDefaultMAILRELAY_DISCORD_TASK_TIMEOUTTimeout for asynchronous Discord requests in seconds.60MAILRELAY_DISCORD_USER_TIMEOUTTimeout for user facing Discord requests in seconds.30MAILRELAY_OLDEST_MAIL_HOURSOldest mail to be forwarded in hours. Set to 0 to disable.2MAILRELAY_RELAY_GRACE_MINUTESMax time in minutes since last successful relay before service is reported as down.30

aa-market-manager

Market Manager for Alliance AuthMarket Manager and Market Browser plugin forAlliance Auth.Inspired byEveMarketer,Fuzzworks Marketand all those that came before themFeaturesMarket BrowserItem Search with AutocompleteBuy/Sell OrdersRegion filteringOrder highlighting on Corporation and User ownership of OrdersItem Statistics, Medians and PercentilesOrder TypesPublic OrdersCharacter OrdersCorporation OrdersPrivate Structures OrdersConfigurable AlertsSupply Alerts, Ensure adequate volume is on the market at a given price.Price Alerts, Highlights orders that breach a given threshold to find Scalpers and market abuse.Price Alerts (Bargains!), Flip the logic to find bargains like dreads in surrounding regions.Alert DestinationsDiscord WebhooksAA Discordbot channel messagesFeatures - TechnicalCorporation OrdersA Title/Role checker, to find valid tokens to fetch orders.Private Structure OrdersRequires mapping tokens to their allowed Structures and/or Corporation's Structures.Structure ID ResolverResolves Stations via Django-EveUniverse EveEntity resolverResolves Citadels internallyFetches Corporation Citadels from Corporation Tokens loaded with the appropriate EVE Roles ("Station_Manager")get_universe_structures_structure_id requires docking ACL Access. As there is no way to tell who has docking (even the owner corporation is not a guarantee),Will detect and use any tokens loaded by other means, if you request the scopes as part of a wider scoped app (Such as an Audit tool etc.)Managed WatchConfigs, to allow external apps to manage and create their own configs.Very basic currentlySupports Generating and maintaining WatchConfigs for a given fit.Planned FeaturesPrivate Structure OrdersFailing to resolve will disable the token mapping to avoid error-bans.Configurable AlertsRe-List detection, Highlight characters buying and relisting items past a configured threshold.Managed WatchConfigs, to allow external apps to manage and create their own configs.Framework exists, need code.Buybacks?!?InstallationStep 1 - Django Eve UniverseMarket Manager is an App forAlliance Auth, Please make sure you have this installed. Market Manager is not a standalone Django ApplicationMarket Manager needs the Appdjango-eveuniverseto function. Please make sure it is installed before continuing.Step 2 - Install apppipinstallaa-market-managerStep 3 - Configure Auth settingsConfigure your Auth settings (local.py) as follows:Add'marketmanager'toINSTALLED_APPSAdd below lines to your settings file:## Settings for AA-MarketManager# Market OrdersCELERYBEAT_SCHEDULE['marketmanager_fetch_public_market_orders']={'task':'marketmanager.tasks.fetch_public_market_orders','schedule':crontab(minute=0,hour='*/3'),}CELERYBEAT_SCHEDULE['marketmanager_fetch_all_character_orders']={'task':'marketmanager.tasks.fetch_all_character_orders','schedule':crontab(minute=0,hour='*/3'),}CELERYBEAT_SCHEDULE['marketmanager_fetch_all_corporation_orders']={'task':'marketmanager.tasks.fetch_all_corporation_orders','schedule':crontab(minute=0,hour='*/3'),}CELERYBEAT_SCHEDULE['marketmanager_fetch_all_structure_orders']={'task':'marketmanager.tasks.fetch_all_structure_orders','schedule':crontab(minute=0,hour='*/3'),}# Structure InformationCELERYBEAT_SCHEDULE['marketmanager_fetch_public_structures']={'task':'marketmanager.tasks.fetch_public_structures','schedule':crontab(minute=0,hour=4),}CELERYBEAT_SCHEDULE['marketmanager_update_private_structures']={'task':'marketmanager.tasks.update_private_structures','schedule':crontab(minute=0,hour=5),}CELERYBEAT_SCHEDULE['marketmanager_fetch_all_corporations_structures']={'task':'marketmanager.tasks.fetch_all_corporations_structures','schedule':crontab(minute=0,hour=6),}# Watch ConfigsCELERYBEAT_SCHEDULE['marketmanager_update_managed_supply_configs']={'task':'marketmanager.tasks.update_managed_supply_configs','schedule':crontab(minute='0',hour='2'),}CELERYBEAT_SCHEDULE['marketmanager_run_all_watch_configs']={'task':'marketmanager.tasks.run_all_watch_configs','schedule':crontab(minute=0,hour='*/3'),}# Background TasksCELERYBEAT_SCHEDULE['marketmanager_update_all_type_statistics']={'task':'marketmanager.tasks.update_all_type_statistics','schedule':crontab(minute=0,hour=0,day_of_week=1),}# CleanupCELERYBEAT_SCHEDULE['marketmanager_garbage_collection']={'task':'marketmanager.tasks.garbage_collection','schedule':crontab(minute='0',hour=0),}Step 4 - Maintain Alliance AuthRun migrationspython manage.py migrateGather your staticfilespython manage.py collectstaticRestart your projectsupervisorctl restart myauth:Step 5 - Pre-Load Django-EveUniversepython manage.py eveuniverse_load_data mapThis will load Regions, Constellations and Solar SystemsStep 6 (Optional) - Further Pre-Load Django-EveUniverseThis is less required the more you have used eveuniverse in the pastpython manage.py eveuniverse_load_data ships --types-enabled-sections EveType.Section.MARKET_GROUPSThis will load Ships, which are nearly universally on the marketpython manage.py eveuniverse_load_data structures, this will load Structures for use in Filterspython manage.py marketmanager_preload_common_eve_typesThis will preload a series of Types using Groups and Categories I've analyzed to be popular on the market, please note this currently will not import MarketGroups until a market update is run for the first time, this may impact your ability to make SupplyConfigs immediately.Step 7 - ConfigurationIn the Admin interface, visitmarketmanageror<AUTH-URL>/admin/marketmanagerPublic Market ConfigurationSelect the Regions you would like to pull Public Market Data forPlease note Jita (The Forge) is not trivial and will take several minutes to pull and process depending on your hardware.TypeStatistics Calculation ConfigurationsSelect the Regions you would like to calculate Percentiles, Medians and Weighted Averages forWe always calculate these stats across New Eden, but these will likely match Public Market Configuration or the regions where your Private Structures are located.Supply Configs require The Forge selected to use The Forge(Jita) Relative Pricing.An item must have a minimum amount of orders to be calculated (see settings)Private ConfigsMap the appropriate tokens with Access to Docking and Market (this cant be assumed), to the right Structures And/Or Corps.WatchConfig TypesConfigure some supply alertsSupply CheckHighlight Types (Items), that fail to meet a defined configVolume of Items at given price in location Example. Warn if there is less than 1,000,000 Units of Oxygen Isotopes under 1,000 ISK/Unit, in 9KOE-A.Bargain Finder WIPHighlights Orders that meet a defined config. Example. Notify if Naglfars under 3,000,000,000 ISK/Unit are on sale in Curse NPC StationsScalp Checker WIPHighlights Orders, that breach Jita/Universe price. Example. Notify Leadership that Ariel Rin is selling Nanite Repair Paste at over 500% Jita price in Staging.Managed Watch ConfigsFittingsManaged By App =fittingsManaged App-Identifier =fittings.fit.<FIT_ID>Managed App Reason = A user facing reason... a slightly limited subset of WatchConfig settings that will be replicated on each WatchConfig created.PermissionsPermAdmin SitePermDescriptionbasic_market_browsernillCan access the Standard Market BrowserCan access the normal user facing market browseradvanced_market_browsernillCan access the Advanced Market BrowserCan access the more advanced management browser with private detailsorder_highlight_usernillCan access other character's data for own alliance.Enables Highlighting a users own Orders in the Market Browserorder_highlight_corporationnillCan access other character's data for own corp.Enables Highlighting the orders of a users corporation in the Market Browsercan_add_token_characternillCan add a Character Token with required scopesEnables the "Add Character Token" button to request the needed scopes from a usercan_add_token_corporationnillCan add a Corporation Token with required scopesEnables the "Add Corporation Token" button to request the needed scopes from a userSettingsNameDescriptionDefaultMARKETMANAGER_CLEANUP_DAYS_STRUCTURENumber of days without an update, before considering a Structure stale and to be deleted30MARKETMANAGER_CLEANUP_DAYS_ORDERNumber of days without an update, before considering an Order stale and to be deleted30MARKETMANAGER_TASK_PRIORITY_ORDERSCelery task priority for Order tasks5MARKETMANAGER_TASK_PRIORITY_STRUCTURESCelery task priority for Structure tasks4MARKETMANAGER_TASK_PRIORITY_BACKGROUNDCelery task priority for Background tasks7MARKETMANAGER_TASK_PRIORITY_SUPPLY_CONFIGSCelery task priority for SupplyConfig tasks, This is Lower than Orders to ensure it runs while Orders are all up to date6MARKETMANAGER_TASK_PRIORITY_PRICE_CONFIGSCelery task priority for PriceConfig tasks, This is Lower than Orders to ensure it runs while Orders are all up to date6MARKETMANAGER_WEBHOOK_COLOUR_ERRORWebhook colour for Errors16711710MARKETMANAGER_WEBHOOK_COLOUR_WARNINGWebhook colour for Errors14177041MARKETMANAGER_WEBHOOK_COLOUR_INFOWebhook colour for Errors42751MARKETMANAGER_WEBHOOK_COLOUR_SUCCESSWebhook colour for Success6684416MARKETMANAGER_TYPESTATISTICS_MINIMUM_ORDER_COUNTMinimum number of Orders to exist before calculating Medians, Averages and Percentiles10Third Party IntegrationsCreating Watch Configs from external applications is relatively straight forward and Market Manager provides an Optional Model for keeping track of these Watch Configs.How an app maintains these Watch Configs is left to the developer, but Fittings provides a decent starting point using App Signals and referencing the Managed Watch Config model.managed_app should follow python referencing convention.fittings,projectname.modulenamemanaged_app_identifier is up to the app, but i would suggest following from Fittings,fittings.fit.{fit.id}managed_app_reason is presented to users as to_why_ a managed config exists,Standard MWD Eagle x50defmarketmanager_active()->bool:returnapps.is_installed("marketmanager")ifmarketmanager_active():frommarketmanager.modelsimportWatchConfig,ManagedAppConfig# ...# Maintain your Watch Configs here# ...Fittings (Currently from Market Manager)Create and Maintain Watch Configs for x number of a Fit or Fits.ContributingMake 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.

aamarpay

Aamarpay Payment Gateway integration in pythonaamarpay is an online payment gateway service for Bangladesh. Committed to provide best payment experience online for business. Lowest fee and fast checkout will give you good experience of receiving payment online.InstallationWe recommend install ``aamarpay`` through pip install . .. code:: bash $ pip install aamarpay Example ~~~~~~~ To make a payment : .. code:: python from aamarpay.aamarpay import aamarPay pay = aamarPay(isSandbox=True,transactionAmount=600) paymentpath = pay.payment() return redirect(paymentpath) # Output: paymentpath output https://sandbox.aamarpay.com/paynow.php?track=AAM1636017211119390# Contribute ~~~~~~~~~~ Create Github Pull Request https://github.com/sanjidbillah/aamarPay-python x Thanks ~~~~~~

aa-ma-securegroups

Member Audit Secure Groups Integration for Alliance AuthThis is an integration betweenMember AuditandSecure GroupsforAlliance Auth(AA).Member Audit Secure Groups Integration for Alliance AuthWhat's the difference to Member Audit SecuregroupsFeaturesInstallationRequirementsStep 0.5 - Migrating from Member Audit SecuregroupsStep 1 - Install the PackageStep 2 - ConfigStep 3 - Finalize App InstallationFiltersChangelogTranslation StatusContributingWhat's the difference to Member Audit SecuregroupsPretty much nothing.I took over Member Audit Securegroups in August 2022 from the original developer who is no longer actively maintaining the app. After more than a year and the fact that I have a distinct dislike for Gitlab and the original developer didn't want to transfer the PyPi repository to me, I decided it is time to make an actual fork of the app which is now again actively maintained by me.This app is fully compatible with the original, all that has changed is thepipname fromaa-memberaudit-securegroupstoaa-ma-securegroups, and if you had the original app installed, it is really easy to switch to this one, seeStep 0.5 - Migrating from Member Audit Securegroups.Thanks to@rcmurphyfor all her work on theoriginal app!FeaturesActivity FilterAsset FilterCharacter Age FilterCompliance FilterSkill Set FilterSkill Point FilterInstallationRequirementsThis integration needsMember AuditandSecure Groupsto function. Please make sure they are installed before continuing.Step 0.5 - Migrating from Member Audit SecuregroupsIn case you have the original app installed, you need to uninstall it before you can continue. To do so, simply run:pipuninstallaa-memberaudit-securegroupsThat's all, no need to worry about the DB related stuff, this app is fully compatible with it and will use the DB tables from the original app. Now feel free to continue with the installation.Step 1 - Install the PackageMake sure you are in the virtual environment (venv) of your Alliance Auth installation. Then install the newest release from PyPI:pipinstallaa-ma-securegroupsStep 2 - ConfigAddmemberaudit_securegroupsto yourINSTALLED_APPS.Step 3 - Finalize App InstallationRun migrations:pythonmanage.pymigrateRestart your supervisor services for AuthFiltersFilter NameMatches if...Activity FilterUser hasat least onecharacter active within the last X daysAge FilterUser hasat least onecharacter over X days oldAsset FilterUser hasat least onecharacter withany ofthe assets definedCompliance FilterUser hasallcharacters registered on Member AuditCorporation Role FilterUser has a character (main or alt) in a certain corpration with a certain roleSkill Point FilterUser hasat least onecharacter with at least X skill pointsSkill Set FilterUser hasat least onecharacter withany ofthe selected skill setsChangelogSeeCHANGELOG.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)

aamaze

maze-packageA python package for generating, solving and displaying mazes.ContentsSetupPre-requisites/Requirements to use the PackageSetting up the Virtual EnvironmentInstalling Dependencies (User Build)Poetrysetup.pyUsing the PackageSupported AlgorithmsGenerating AlgorithmsSolving AlgorithmsBasic use case: Create a Maze and SolutionGenerating a Maze solution at runtimeManipulating the solving algorithm at runtimeConfiguring GraphicsAppOption input types KeyFull list of optionsOther functionalityConfiguring the GrowingTree Maze Generation AlgorithmSetupPre-requisites/Requirements to use the PackagePython version 3.7+ (Program originally written using Python 3.9 interpreter)Setting up the Virtual EnvironmentIt is good practice to create a virtual environment for this project (and for any other project with non-standard-library dependencies). See this guide for how to setup and activate a virtual environment:Python docsNOTE: Ensure that you activate the environment once you have created it (See Python docs)Installing Dependencies (User Build)Note: This guide assumes you are in the root project directoryPoetryIf you have poetry installed on your machine, simply run poetry install.setup.pyTo install the relevant packages, select the directory that requirements.txt is in and run the following command:pip install .To check that all the packages have been installed, run the following command:pip listThis should produce an output that contains these itemsPackage Version ---------- ------- aamaze latest_version pip 20.2.3 pygame 2.3.0 setuptools 49.2.1You are now ready to make Mazes!Using the PackageSupported AlgorithmsGenerating AlgorithmsEllerGrowingTreeKruskalsPrimsRecursiveBacktrackerRecursiveDivisorWilsonsAll Generation algorithms (with the exception of RecursiveDivisor) require a maze with all walls filled(start_filled=True)Solving AlgorithmsAStarSolverDijkstraSolverFloodFillSolutionCheckAStarSolver and DijkstraSolver find the shortest path between a Maze's entrance and exit. FloodFillSolutionCheck checks to see if every node in a maze can be reached from every other node.Basic use case: Create a Maze and SolutionCreating a Maze and Solution to a Maze can be done in the following way:Create a new Maze Object (In this case a 20x10 Maze)from aamaze import Maze maze = Maze(20, 10, start_filled=True, entrance_index=0, exit_index=-1)Create a new GenerationAlgorithm ObjectRun the "generate_maze" method on GenerationAlgorithm Objectfrom aamaze.generation import X_GeneratingAlgorithm X_GenerationAlgorithm(maze).generate_maze()Create a new SolvingAlgorithmRun the "solve_maze" method on SolvingAlgorithm Objectfrom aamaze.solving import Y_SolvingAlgorithm maze_solver = Y_SolvingAlgorithm(maze) maze_solver.solve_maze()The Objects you want to keep in this case are "maze" and "maze_solver". The GenerationAlgorithm can be safely discarded once its "generate_maze" has been run.Basic use case: Displaying a Maze and its solutionTo display a maze and itssolution (optional):Generate maze and solution Objects (as shown inBasic use case: Create a Maze and Solution).Create a GraphicsApp Objectfrom aamaze import GraphicsApp app = GraphicsApp(maze, solver) # solver is optionalCall the "run" method on the GraphicsApp Objectapp.run()Calling "app.run()" should open a new pygame Window that displays the Maze and its associated Solution (if a solution object is provided).Generating a Maze solution at runtimeaamaze allows for solutions to be generated dynamically while the GraphicsApp is running. To do this:Create a maze using the workflow described in Basic use case: Create a Maze and Solution (1-4) DO NOT run "solve_maze" on the SolvingAlgorithm.from aamaze import Maze from aamaze.generation import X_GeneratingAlgorithm from aamaze.solving import Y_SolvingAlgorithm maze = Maze(20, 10, start_filled=True, entrance_index=0, exit_index=-1) X_GenerationAlgorithm(maze).generate_maze() maze_solver = Y_SolvingAlgorithm(maze)Create a GraphicsApp objectfrom aamaze import GraphicsApp app = GraphicsApp(maze, maze_solver)(Optional) Configure whether a solution starts to be generated as soon as "app.run()" is called (start_paused), and the speed of generation (target_steps_per_second). By default, start_paused=False, target_steps_per_second=50app.configure(start_paused=True, target_steps_per_second=50)Run the app as usualapp.run()Manipulating the solving algorithm at runtimeControls for manipulating the solving algorithm at runtime are:[SPACE] topause/unpausesolving algorithm generation[S] tomanually run one stepof the solving algorithm[R] toresetsolving algorithm[+] toincreasetarget_steps_per_second (speed of solution generation)[-] todecreasetarget_steps_per_second (speed of solution generation)Configuring GraphicsAppBelow are all options that can be set using the app.configure() method. Options are always set using keyword args (var_x = val_y). Multiple options can be set in the same app.configure call. Available options can be printed via accessing the ".options_list" property of a GraphicsApp object instance. Examples:app = GraphicsApp(maze) app.configure(aspect_ratio=[16, 10]) app.configure(exit_colour=[200, 32, 32], entrance_colour=[32, 200, 32]) app.configure(window_width=1600, wall_colour=[0, 0, 0], show_fps_counter=True)Option input types KeyColour:Set using RGB values between 0 and 255 (inclusive). Takes 3 integers in a List, Tuple or any other object that is subscriptable.e.g. [200, 200, 205], (0, 4, 8), [255, 32, 16]Pair of Numbers:Takes 2 numbers in a List, Tuple or any other object that is subscriptable.e.g. [200, 100], (16, 9), [6, 4.5]Bool:Takes a standard python bool.e.g. True, FalsePositive Integer:Takes a standard python integer that is greater than or equal to 0.e.g. 0, 253, 1000000Full list of optionsaspect_ratio:Sets the aspect ratio that the GraphicsApp window will open at (e.g. [16, 9]). -Pair of Numbersbackground_colour:Sets the background colour of the GraphicsApp window (e.g. [200, 200, 205]). -Colourentrance_colour:Sets colour of Start/Entrance tile of maze. -Colourexit_colour:Sets colour of End/Exit tile of maze. -Colourshow_fps_counter:Determines whether fps counter is displayed in the top right of the GraphicsApp window. -Boolshow_step_counter:Determines whether target steps per second counter is displayed in the top right of the GraphicsApp window. -Boolsolution_colour:Sets the colour of solution nodes -Colourstart_paused:Determines whether the maze tries to start generating a solution as soon as GraphicsApp window is opened -Booltarget_fps:Target Frames per Second of the GraphicsApp window. -Positive Integertarget_steps_per_second:Target number of times step() method is called on the SolvingAlgorithm -Positive Integerwall_colour:Sets colour of maze walls -Colourwindow_width:Sets the width of the GraphicsApp window -Positive IntegerOther functionalityConfiguring the GrowingTree Maze Generation AlgorithmCurrently, GrowingTree is a special GeneratingAlgorithm that allows for editing how a maze is generated. This can be done by setting thenode_selection_modeattribute to one of three valuesrandom- The next path will start at a random node that has already been visited (approximates Prims Algorithm)newest- The next path will start at the most recently visited node that still has an unvisited neighbour (approximates Recursive Backtracker Algorithm)random-newest-split-x- The next path has anx% probability to start from a random node, and anx-100% chance of starting from the most recently visited node with an unvisited neighbour.See implementation below:maze = Maze(16, 16, start_filled=True) # Creating 16x16 maze growing_tree = GrowingTree(maze) # Created GrowingTree instance growing_tree.node_selection_mode = "random" # Randomly select node growing_tree.node_selection_mode = "newest" # Select newest node with unvisited neighbour growing_tree.node_selection_mode = "random-newest-split-25" # 25% chance random, 75% change newest growing_tree.node_selection_mode = "random-newest-split-50" # 50% chance random, 50% change newest growing_tree.node_selection_mode = "random-newest-split-98" # 2% chance random, 98% change newestEND

aa-memberaudit

Member AuditAn Alliance Auth app that provides full access to Eve characters and related reports for auditing, vetting and monitoring.ContentsOverviewFeaturesHighlightsDocumentationOverviewMember Audit is an Alliance Auth app that provides full access to Eve characters and related reports.Users can monitor their characters, recruiters can vet the characters of applicants and leadership can audit the characters of their members to ensure compliance and find spies.In addition character based reports gives leadership another valuable tool for managing their respective organization.FeaturesMember Audit adds the following features to Auth:Users can see an overview of all their characters with key information like their current location and wallet balanceUsers can get full access to their characters to monitor them without having to open the Eve client (similar to the classic Eve ap "EveMon").Applicants can temporarily share their characters with recruiters for vettingLeadership can get full access to characters of their members for auditing (e.g. to check suspicious members)Full access to characters currently includes the following information:AssetsBioContactsContractsCorporation historyCorporation roles (NEW)Faction Warfare statisticsImplantsJump clonesMailsMining ledgerLoyalty pointsSkill queueSkill setsSkillsWallet (journal and transactions)Leadership can define Skill Sets, which are a way of defining skills needed to perform a specific activity or fly a doctrine ship. They allow recruiters and leadership to see at a glance what a character can do (e.g. which doctrine ships he/she can fly)Skill Sets can be generated from imported fittingsLeadership can see reports and analytics about their members. Those currently include:Compliance: if users have added all their charactersSkill Sets: which character has which skill setsAdmins can use the flexible permission system to grant access levels for different roles (e.g. corp leadership may only have access to reports about their own corp members)Admins can customize and configure Member Audit to fit their needs. e.g. change the app's name and define how often which type of data is updated from the Eve serverEnsure that only users who have registered all their characters have access to services (see alsoCompliance Groups)Get notifications when a user removes a character that they had previously registered.Designed to work efficiently with large number of charactersData retention policy allows managing storage capacity needsData can be exported for processing it with third party apps like Google Sheets (currently wallet journal only)Language support for Chinese :cn:, English :us:, German :de:, Russian :ru: and Ukrainian 🇺🇦HighlightsCharacter LauncherThe main page for users to register their characters and get a key infos of all registered characters.Character ViewerThe page for displaying all details about a character.Skill SetsSkill sets are a way of defining both required and recommended skills for a specific activity or ship.This tab on the character view allows you to view what skill sets a character has. For skill sets they don't have or are missing parts of, it also shows what skills are missing.Requirements can be customized per skill set in the administration panel. Recommended skill levels can be added in addition to requirements.Character FinderOn this page recruiters and leadership can look for other characters to view (assuming they have been given permission).DocumentationLink todocumentation.

aa-memberaudit-securegroups

Member Audit Secure Groups Integration for Alliance AuthThis is an integration betweenMember AuditandSecure GroupsforAlliance Auth(AA).Member Audit Secure Groups Integration for Alliance AuthFeaturesInstallationRequirementsStep 1: Install the PackageStep 2: ConfigStep 3: Finalize App InstallationFiltersChangelogFeaturesActivity FilterAsset FilterCharacter Age FilterCompliance FilterSkill Set FilterSkill Point FilterInstallationRequirementsThis integration needsMember AuditandSecure Groupsto function. Please make sure they are installed before continuing.Step 1: Install the PackageMake sure you are in the virtual environment (venv) of your Alliance Auth installation. Then install the newest release from PyPI:pip install aa-memberaudit-securegroupsStep 2: ConfigAddmemberaudit_securegroupsto yourINSTALLED_APPS.Step 3: Finalize App InstallationRun migrations:pythonmanage.pymigrateRestart your supervisor services for AuthFiltersFilter NameMatches if...Activity FilterUser hasat least onecharacter active within the last X daysAge FilterUser hasat least onecharacter over X days oldAsset FilterUser hasat least onecharacter withany ofthe assets definedCompliance FilterUser hasallcharacters registered on Member AuditSkill Point FilterUser hasat least onecharacter with at least X skill pointsSkill Set FilterUser hasat least onecharacter withany ofthe selected skill setsChangelogSeeCHANGELOG.md

aa-mengjianing

No description available on PyPI.

aa-miningtaxes

Mining TaxesAn Alliance Auth app for tracking mining activities and charging taxes.Credit to AA'smemberauditandbuybackplugins which formed the foundation for this plugin.ScreenshotsFeaturesMonthly leaderboards to show top miners.Supports multiple corps under one system (Add one character with the accountant role per corp in the admin setup)Supports corp moon mining tracking.Able to track when unrecognized characters are mining your corp's private moons.Tax credit system to offset, zero, or award tax credits to a given user.Supports separate tax rates for Regular Ore, Mercoxit, Gas, Ice, R64, R32, R16, R8, and R4.Tracks tax payments into the corp master wallet filtering with a user defined phrase.Set a monthly interest rate that penalizes for unpaid tax balances.Automatic monthly notifications and monthly interest applied with unpaid balance.Supports Fuzzworks and Janice for daily price updates.Supports refined price calculation versus raw ore prices (the higher price will be the taxed price).Supports multiple mining characters under one user.Monthly statistics and detailed tax calculations available to each user and auditor.Provides a current Ore price chart that is updated each day with the latest prices.Export tax information in CSV format.Installation instructionsIf you would like to useJanicefor pricing information, obtain an API key by following the instructions at the top of theSwagger documentationandFAQ.Install using pip:pip install aa-miningtaxesAddminingtaxesand 'django_celery_results' to INSTALLED_APPS inmyauth/settings/local.pyRun migrations:python manage.py migrateCollect and deploy static assets:python manage.py collectstaticPreload pricing informationpython manage.py miningtaxes_preload_pricesSet local settingsCELERY_RESULT_BACKEND = 'django-db' CELERY_CACHE_BACKEND = 'django-cache' MININGTAXES_PRICE_JANICE_API_KEY = "XXXX" MININGTAXES_PRICE_METHOD = "Janice" CELERYBEAT_SCHEDULE['miningtaxes_update_daily'] = { 'task': 'miningtaxes.tasks.update_daily', 'schedule': crontab(minute=0, hour='1'), } # Notifiy everyone of their current taxes on the second day of every month. CELERYBEAT_SCHEDULE['miningtaxes_notifications'] = { 'task': 'miningtaxes.tasks.notify_taxes_due', 'schedule': crontab(0, 0, day_of_month='2'), } # Charge interest and notify everyone on the 15th of every month. CELERYBEAT_SCHEDULE['miningtaxes_apply_interest'] = { 'task': 'miningtaxes.tasks.apply_interest', 'schedule': crontab(0, 0, day_of_month='15'), }Navigate to the admin panel and setup the accountants (1 per corp)Post-Setup instructionsAfter you have setup your accountants (1 per corp) in the Admin Setup panel, invite all the members of your corp to add their characters.If you enableMININGTAXES_TAX_ONLY_CORP_MOONS, remember that only moon mining of your corp moons will be taxes and other moons will be ignored.After everyone in the corp has added their characters, consider running to theminingtaxes_zero_allcommand to zero out everyone's taxes to prevent mining activity from the past from being taxed.When a new user joins your corp and adds their character to the plugin, also consider going into the audit tables and providing a tax credit so that it will zero out their past mining activity.Local settingsNameDescriptionDefaultMININGTAXES_UNKNOWN_TAX_RATEThe tax rate when a new type of ore is encountered that has not yet been added to the plugin in float (eg 0.10 means 10%)0.10MININGTAXES_TAX_ONLY_CORP_MOONSOnly tax corporate moons using moon observers as opposed to all moons appearing in the personal mining ledgers.TrueMININGTAXES_UPDATE_LEDGER_STALEMinutes after which a character's mining ledger is considered stale240MININGTAXES_REFINED_RATERefining rate for ores.0.9063MININGTAXES_ALWAYS_TAX_REFINEDAlways tax the refined rate instead of the raw ore price (if higher)FalseMININGTAXES_PRICE_METHODBy default Fuzzwork API will be used for pricing, if this is set to "Janice" then the Janice API will be used.FuzzworkMININGTAXES_PRICE_JANICE_API_KEYThe API key to access Janice API.MININGTAXES_PRICE_SOURCE_IDStation ID for fetching base prices. Supports IDs listed onFuzzworks API. Does not work with Janice API!60003760MININGTAXES_BLACKLISTList of system names that taxes should be ignored in. Case sensitive.[]MININGTAXES_TAX_HISECInclude taxing for mining activity in High Security SpaceTrueMININGTAXES_TAX_LOSECInclude taxing for mining activity in Low Security SpaceTrueMININGTAXES_TAX_NULLSECInclude taxing for mining activity in Null Security SpaceTrueMININGTAXES_TAX_JSPACEInclude taxing for mining activity in J-Space (Wormhole)TrueMININGTAXES_TAX_POCHVENInclude taxing for mining activity in Pochven (Trig Space)TruePermissionsNamePurposeExample Target Audiencebasic_accessCan access this app and see own tax information, current ore prices, and FAQ.Member Stateauditor_accessCan view everyone's tax information and see statistics on taxes.Auditorsadmin_accessCan set tax rate and add characters with the accountant role to pull information from the corp Master Wallet and the corp moons.LeadershipCommandsNameDescriptionminingtaxes_preload_pricesPreload all ores and refined materials from chosen Pricing API (Fuzzworks or Janice).miningtaxes_zero_allZero the tax balance of ALL characters.miningtaxes_update_manualTrigger a manual update for all data

aamnotifs

UNKNOWN

aamoer

Specify some function and an iterable of iterables (like a list of lists), where the inner iterable is a row in a data table.Receive histograms of the results of those functions. You receive one histogram per function per column. That is, if each row is eight long and you pass two functions, you’ll get 16 histograms.

aa-moonmining

Moon MiningAn Alliance Auth app for tracking moon extractions and scouting new moons.ContentsFeaturesInstallationUser manualPermissionsSettingsManagement CommandsFAQHistoryChange LogFeaturesUpload survey scans and research your moon databaseMonitor active extractions from your refineriesPrice estimates for potential monthly income of moons and for extractionsMining ledger per extractionReports (e.g. potential total income of all owned moons)Tool for mass importing moon scans from external sourcesHintIf you like to see all extraction events in a calendar view please consider checking out the amazing appAllianceauth Opcalendar, which is fully integrated withMoon Mining.HighlightsResearch your moon databaseBuild your own moon database from survey inputs and find the best moons for you. The moon rarity class and value are automatically calculated from your survey input.See the exact ore makeup of this moon on the details page.Note that you can also see on this list which moons you already own. In addition an extraction button is visible, when an extraction is active for a particular moon.Manage extractionsAfter you added your corporation you can see which moons you own and see upcoming and past extractions:You can also review the extraction details, incl. which ore qualities you got.Mining ledgerSee what has been minded from an extraction in the mining ledger:ReportsCheck out the reporting section for detail reports on your operation, e.g. Breakdown by corporation and moon of your potential total gross moon income per months:NoteAll ore compositions and ISK values shown on these screenshots are fake.InstallationStep 1 - Check prerequisitesMoon Mining 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)Moon Mining needs the appdjango-eveuniverseto function. Please make sure it is installed, before before continuing.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-moonminingStep 3 - Configure Auth settingsConfigure your Auth settings (local.py) as follows:Add'moonmining'toINSTALLED_APPSAdd below lines to your settings file:CELERYBEAT_SCHEDULE['moonmining_run_regular_updates']={'task':'moonmining.tasks.run_regular_updates','schedule':crontab(minute='*/10'),}CELERYBEAT_SCHEDULE['moonmining_run_report_updates']={'task':'moonmining.tasks.run_report_updates','schedule':crontab(minute=30,hour='*/1'),}CELERYBEAT_SCHEDULE['moonmining_run_value_updates']={'task':'moonmining.tasks.run_calculated_properties_update','schedule':crontab(minute=30,hour=3)}Hint: The value updates are supposed to run once a day during off hours. Feel free to adjust the timing according to your timezone.Optional: 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.Step 5 - Load ores from ESIPlease run the following management command to load all ores from ESI. This has to be done once only.pythonmanage.pymoonmining_load_evePlease wait until the loading is complete before continuing.NoteYou can monitor the progress on by looking at how many tasks are running on the dashboard.Step 6 - Load prices from ESIIn order to get the current prices from ESI initially, please run the following command (assuming the name of your Auth installation ismyauth):pythonmanage.pymoonmining_calculate_allPlease wait until the loading is complete before continuing.HintYou can monitor the loading progress on the dashboard. As long as the Task Queue shows more than 0 tasks the process is most likely still ongoing.Step 7 - Update EVE Online API ApplicationUpdate the Eve Online API app used for authentication in your AA installation to include the following scopes:esi-industry.read_corporation_mining.v1esi-universe.read_structures.v1esi-characters.read_notifications.v1Step 8 - Setup permissionsFinally you want to setup permission to define which users / groups will have access to which parts of the app. Check outpermissionsfor details.Congratulations! You are now ready to use Moon Mining!User ManualPricingThe app uses average market prices as basis for all price calculations. Average market prices are same prices that you also see in the Eve client e.g. for the mining ledger or fitting costs. These can be slightly different from Jita prices, since they are represent an average across all of New Eden, not just Jita / The Forge.The calculation of ore prices can be done in two different ways.Default ore pricingThe default ore pricing uses the average market prices directly to calculate ore prices. This is the same approach that the Eve client uses in the mining ledger or when scheduling an extraction. So the main benefit of this approach that you will see the same prices in-game and in the app.Reprocess ore pricingThe disadvantage of this approach is that average market prices for ores are not always accurate. Ores are rarely sold directly on the market, instead most people of refining their ores and selling the refined materials instead. This is because they have they are much smaller in volume making them easier to transport. The total value of the refined materials is also often higher then the value of the ore.Therefore you can also chose to use refined ore pricing. This will give you more accurate prices, but the values will be very different from what you may be used to see in the Eve client. For this approach the app calculates the price for a unit of ore as the sum total of it's refined materials. For the materials again the average market price is used.Please see the settingsMOONMINING_USE_REPROCESS_PRICINGandMOONMINING_REPROCESSING_YIELDfor configuring the ore pricing approach.After you changed the settings for price calculation, you please restart your AA services so that the changes to your settings become effective. Next please run the following command to recalculate all prices:pythonmanage.pymoonmining_calculate_allNoteYou can see the current prices used for all ores in the app in the ore prices report.LabelsTo help with organizing your moons you can label them. For example you might have some of your moons rented out to a third party. Just add a label "Rented out to X" to those moons and the moons and related extractions will show that label allowing you to quickly recognize which are related to your renters.Labels are created on the admin site under Label and can then be assigned under Moon.PermissionsHere is an overview of all permissions:NameDescriptionmoonmining.basic_accessThis is access permission, users without this permission will be unable to access the plugin.moonmining.upload_moon_scanThis permission allows users to upload moon scan data.moonmining.extractions_accessUser can access extractions and view owned moons.moonmining.reports_accessUser can access reports.moonmining.view_all_moonsUser can view all moons in the database and see own moons.moonmining.add_refinery_ownerThis permission is allows users to add their tokens to be pulled from when checking for new extraction events.moonmining.view_moon_ledgersUsers with this permission can view the mining ledgers from past extractions from moons they have access to.SettingsHere 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.NameDescriptionDefaultMOONMINING_ADMIN_NOTIFICATIONS_ENABLEDwhether admins will get notifications about important events like when someone adds a structure ownerTrueMOONMINING_COMPLETED_EXTRACTIONS_HOURS_UNTIL_STALENumber of hours an extractions that has passed its ready time is still shown on the upcoming extractions tab.12MOONMINING_REPROCESSING_YIELDReprocessing yield used for calculating all values0.85MOONMINING_USE_REPROCESS_PRICINGWhether to calculate prices from it's reprocessed materials or not. Will use direct ore prices when switched offFalseMOONMINING_VOLUME_PER_DAYMaximum ore volume per day used for calculating moon values.960400MOONMINING_DAYS_PER_MONTHAverage days per months used for calculating moon values.30.4MOONMINING_OVERWRITE_SURVEYS_WITH_ESTIMATESWhether uploaded survey are automatically overwritten by product estimates from extractions to keep the moon values currentFalseManagement CommandsThe following management commands are available to perform administrative tasks:Hint:Run any command with--helpto see all optionsNameDescriptionmoonmining_calculate_allCalculate all properties for moons and extractions.moonstuff_export_moonsExport all moons from aa-moonstuff v1 to a CSV file, which can later be used to import the moons into the Moon Mining appmoonmining_load_evePre-loads data required for this app from ESI to improve app performance.moonmining_import_moonsImport moons from a CSV file. Example:moon_id,ore_type_id,amount40161708,45506,0.19FAQExtractionsQ: Why does the tool not show values and ores for all my extractions?A: Unfortunately, the Eve Online API does only provide basic information for extractions. Additional information like the list of ores are retrieved by trying to match moon mining notifications to extractions. However, that process it not 100% reliable. For example the API returns the latest notifications only, so notifications for extractions that have been setup weeks ago might no longer be available.PricesQ: How are the prices and values of ores calculated?A: All ore prices areaverage prices(not Jita prices), which are the current average price of an item accross all of New Eden and the same that the in-game client is showing, e.g. for price estimates when scheduling an extraction.HistoryThis project started as a fork fromaa-moonstuffin 2019, but as diverged heavily since then through two major iterations. The first iteration was called Moon Planner and used internally. It had a very different data model build uponallianceauth-evesde. The current version is the second iteration and is build upondjango-eveuniverse. Nevertheless, we like to take the opportunity to thank @colcrunch for providing a great starting point with moonstuff.

aa-moonstuff

MoonstuffContentsOverviewKey FeaturesScreenshotsInstallationUpdatingSettingsPermissionsCreditsOverviewMoonstuff is anAllianceAuthplugin focused on managing moons, from keeping track of moonscan data to making sure everyone knows when and where the next extraction will be.Key FeaturesAutomatically pulls upcoming extractions from ESI.Automatically updates ore composition, just in case CCP decides to shuffle moon ore around.Pulls mining ledger data for all extractions as they happen.Mining Ledger Data is used to track whether or not extractions are jackpots.[Coming Soon] A mining ledger explorer is planned.Per-m3 values are displayed per ore, customized based on a customizable refine percent. (So if you don't have a T2-rigged Null Sec Tatara and perfect skills, you can see a more realistic value)Search for R-value or ore type from moon list.Moons will show all rarity values available for that moon, rather than just the top value.ScreenshotsDashboardCalendar ViewCard ViewJackpotMoon Info(Moon info page is identical)Moon ListSearchInstallation1. Install AppInstall the app into your allianceauth virtualenvironment via PIP.$pipinstallaa-moonstuff2. Configure AA SettingsConfigure your AA settings (local.py) as follows:Add'eveuniverse',and'moonstuff',toINSTALLED_APPSAdd the following lines to the end of your settings file to ensure that the proper tasks are scheduled to run# Moonstuff ModuleEVEUNIVERSE_LOAD_TYPE_MATERIALS=TrueCELERYBEAT_SCHEDULE['moonstuff_import_extraction_data']={'task':'moonstuff.tasks.import_extraction_data','schedule':crontab(minute='*/10'),}CELERYBEAT_SCHEDULE['moonstuff_run_ledger_update']={'task':'moonstuff.tasks.update_ledger','schedule':crontab(minute=0,hour='*'),}CELERYBEAT_SCHEDULE['moonstuff_run_refinery_update']={'task':'moonstuff.tasks.update_refineries','schedule':crontab(minute=0,hour=0),}CELERYBEAT_SCHEDULE['moonstuff_run_price_update']={'task':'moonstuff.tasks.load_prices','schedule':crontab(minute=0,hour=0),}Note: The last two tasks can be schdeuled at whatever time is best for you, though they need only be run once per day.Optional: Add any settings listed insettingsif you would like to change the default values.3. Run MigrationsRun migrations and copy static files.$pythonmanage.pymigrate $pythonmanage.pycollectstaticRestart your supervisor tasks.4. Load Eveuniverse DataRun the following command to pull the required eveuniverse data required for moonstuff.$pythonmanage.pymoonstuff_preload_dataUpdatingTo update your existing installation of Moonstuff first enable your virtual environment.Then run the following commands from your allianceauth project directory (the one that containsmanage.py).$pipinstall-Uaa-moonstuff $pythonmanage.pymigrate $pythonmanage.pycollectstaticLastly, restart your supervisor tasks.Note: Be sure to follow any version specific update instructions as well. These instructions can be found on theTagspage for this repository.SettingsSetting NameDescriptionDefaultMOON_REFINE_PERCENTThis setting defines the refine percent to use when calculating ore values.(0.876and87.6are both acceptable formats)87.6DEFAULT_EXTRACTION_VIEWThis setting allows you to configure if you would like the calendar or card view to show by default when the dashboard loads.(Options are"Calendar"or"Card")"Calendar"PermissionsPermission NameAdmin SiteAuth SiteMoonstuff.access_moonstuffNoneCan access the moonstuff module.Moonstuff.access_moon_listNoneCan access the list of known moons.Resource.add_resourceNoneCan add access the add_scan page to add moon scan data.TrackingCharacter.add_trackingcharacterNoneCan link a character to be used in tracking extractions.ScopesThough accepted best practice for auth is to ensure that one's ESI application has access to all scopes through the EVE Development portal, if you are not following this practice please make sure to include the following scopes in your ESI application.ScopePurposeesi-industry.read_corporation_mining.v1This is required to pull corporation moon extraction data. (The in-game Station_Manager and Accountant roles are required)esi-universe.read_structures.v1Required to pull structure names.esi-characters.read_notifications.v1Required to pull character notifications used for updating resource data.CreditsThis plugin makes use ofdjango-eveuniverseby @ErikKalkoken

aamp

Nintendo parameter archive (AAMP) libraryEverything should work correctly for BotW parameter archives, though this hasn't been tested a lot.Some more esoteric parameter types are left unsupported currently.SetupInstall withpip install aampor on Windowspy -m pip install aamp.Converter usageaamp_to_ymlwill convert an AAMP to a human readable representation.yml_to_aampwill do the opposite.Library usageTo read a parameter archive, create a Reader and give it the binary archive data, then callparse()to get a ParameterIO. This API is purposefully very similar to Nintendo's official parameter utils to help with reverse engineering and re-implementing parts of the game code.Parameter is a simple value, for example a boolean or an integer.ParameterObject is a key-value mapping where keys are strings and values are always Parameters.ParameterList is also a key-value mapping, but it contains objects and other lists rather than Parameters.ParameterIO is a special ParameterList with some extra attributes, like a version number and a type string (usuallyxml).>>>importaamp>>>reader=aamp.Reader(open('test_data/DamageReactionTable.bxml','rb').read())>>>pio=reader.parse()>>>pio.list('param_root').list('Basic').object('Edge')ParameterObject(params={375673178:True,2982974660:True,4022901097:True,2861907126:True,3947755327:True,1529444359:False})>>>pio.list('param_root').list('Basic').object('Edge').param('Damage')TrueParameterObject:.param(param_name)returns a parameter. KeyError is raised if the parameter doesn't exist..set_param(param_name, value)ParameterList:.list(list_name)returns a parameter list. KeyError is raised if the list doesn't exist..object(object_name)returns a parameter object. KeyError is raised if the object doesn't exist..set_list(list_name, param_list).set_object(object_name, param_object)ParameterIO:Same as ParameterList, but with extra attributesversion(usually 0) andtype(usuallyxml).For writing a binary parameter archive, create a Writer and pass it a ParameterIO, then callwrite(stream)with a seekable stream.LicenseThis software is licensed under the terms of the GNU General Public License, version 2 or later.