Saravanan666/pypi-org huggingface dataset:
Package: xenolith
XenolithXenolith is a command-line based tool that allows for files to be encrypted with public keys and decrypted by users who have . With the main components being FiloSottile'sageand str4d'sragelibrary for encryption, Xenolith usesssh-rsa,ssh-ed25519, and age/rages'skeygenas keys.InstallationRequirementsInstallageorrageUsePython 3.8.4or higherInstallationInstall using pippip install xenolithUsageXenolith uses 5 commands:- xenolith
Contains a list of all the commands


- xenolith init [--encryption, -e]
Initializes the project in the given directory by creating a .secret folder. This folder contains a `recipients.txt` and `config.json` file.

Options:
-e, --encryption    Specifies an encryption library (age, rage). Defaults to age


- xenolith encryption [age/rage]
Changes the encryption library to age or rage


- xenolith add [key]
Adds a public key (Recipient) to the list of recipients that can access an encrypted file.


- xenolith remove [key]
Removes a public key from the list of recipients. The key must match one of the keys found in `.secret/recipients.txt`


- xenolith encrypt [file_name]
With a given set of recipients, encrypts the given file and appends an .age suffix at the end.


- xenolith decrypt [key_file] [file_path]
With a given key and file, decrypts a file that have been previously encrypted.ContributingTo get started:DownloadPython 3.8.4Set upPython's Virtual Environmentpython3 -m venv venvDownload the project's requirements and run venvpip install -r requirements.txt
source ./venv/bin/activateInstallageandrageTo test the application locally, run:pip install --editable .Tests can be run by executingrun_tests.shfound in thebin/folderLicenseThis project uses theMITlicense.
Package: xenon
Xenon is a monitoring tool based onRadon.
It monitors your code’s complexity.  Ideally, Xenon is run every time you
commit code. Through command line options, you can set various thresholds for
thecomplexityof your code. It will fail (i.e. it will exit with a
non-zero exit code) when any of these requirements is not met.InstallationWith Pip:$pipinstallxenonOr download the source and run the setup file (requires setuptools):$pythonsetup.pyinstallXenon is tested with all versions of Python from2.7to3.6as well asPyPy.UsageTypically you would use Xenon in two scenarios:As agit commithook: to make sure that your code never exceeds some
complexity values.On acontinuous integrationserver: as a part of your build, to keep
under control, as above, your code’s complexity. See Xenon’s.travis.yml filefor an example usage.The command lineEverything boils down to Xenon’s command line usage.
To control which files are analyzed, you use the options-e,--excludeand-i,--ignore. Both accept a comma-separated list of glob patterns. The
value usually needs quoting at the command line, to prevent the shell from
expanding the pattern (in case there is only one). Every filename is matched
against theexcludepatterns. Every directory name is matched against theignorepatterns.  If any of the patterns matches, Xenon won’t even descend
into them.The actual threshold values are defined through these options:-a,--max-average: Threshold for theaveragecomplexity (across all the
codebase).-m,--max-modules: Threshold formodulescomplexity.-b,--max-absolute:Absolutethreshold forblockcomplexity.All of these options are inclusive.An actual example$xenon--max-absoluteB--max-modulesA--max-averageAor, more succinctly:$xenon-bB-mA-aAWith these options Xenon will exit with a non-zero exit code if any of the
following conditions is met:At least one block has a rank higher thanB(i.e.C,D,EorF).At least one module has a rank higher thanA.The average complexity (among all of the analyzed blocks) is ranked withBor higher.Other resourcesFor more information regarding cyclomatic complexity and static analysis in
Python, please refer to Radon’s documentation, the project on which Xenon is
based on:More on cyclomatic complexity:http://radon.readthedocs.org/en/latest/intro.htmlMore on Radon’s ranking:http://radon.readthedocs.org/en/latest/commandline.html#the-cc-command
Package: xenon-fuse
XENON fuseFramework forUnifiedSimulation ofEventsfuse is the refactored version of the XENONnT simulation chain. The goal of this project is to unifyepixandWFSiminto a single program. fuse is based on thestrax framework, so that the simulation steps are encoded in plugins with defined inputs and outputs. This allows for a flexible and modular simulation chain.InstallationWith all requirements fulfilled (e.g., on top of theXENONnT montecarlo_environment):python -m pip install xenon-fuseor install from source:git clone git@github.com:XENONnT/fuse
cd fuse
python -m pip install . --userPlugin StructureThe full simulation chain in split into multiple plugins. An overview of the simulation structure can be found below.
Package: xenon-lfp-analysis
Xenon LFP Analysis PlatformIntroductionThis is an interactive platform for analyzing bandpass filtered (1 to 2048 Hz) Local Field Potential (LFP) activity and seizure-like activity. This Graphical User Interface (GUI) is built in Python using Plotly's Dash library for interactive visualizations, this includes several features to generate summary measures, plots, trace LFP activity over time, and for people familiar with basic Python this can also serve as a boiler plate to customize, add functions and visualization based on individual researchers’ analysis requirements. We demonstrate this new python-based software tool for analysis and tracking of local field potential activity using the 3Brain MEA recording system but it can easily be adapted to any MEA recording platform. This GUI is also easily adaptable to large-scale EEG recordings and likely can provide a useful mapping tool for In-Vivo LFP activity.  Our current GUI has a particular utility for analysis of seizure-like activity but can be used for analysis of any network LFP signal.Installation:pip install xenon_lfp_analysisRun the Xenon LFP Analysis GUI:After installation you can run the GUI by running the following command in the terminal:$>run_lfp_analysisDocumentationhttps://xenon-lfp-analysis.readthedocs.io/en/latest/index.htmlPrePrinthttps://www.biorxiv.org/content/10.1101/2022.03.25.485521v1
Package: xenopict
XenopictXenopict is a package for generating publication quality 2D depictions of small molecules,
with special attention to "shading" molecules with atom or bond level properties. This package
relies on RDKit generation an initial SVG depiction of the input molecule.Read thedocumentationfor more information.This package is in beta. It's API is still subject to substantial revisions. It is in active use by our laboratory,
and several bugs and features are added frequently.
Package: xenoponics
XenoponicsA repository for scripts and other tools to run hydroponics systems in a smarter way.Configured Scriptscontrol.pySummaryThe management script for our current Raspberry Pi setup.
UsesTyper,python-requests, and Python stdlib to perform POST requests toXenoAPI, which is a GraphQL API that handles database interactions.RequirementsPython 3.8+SetupImplicit purchase a Raspberry Pi and sensors and set it up goes hereMake a virtualenvpython3-mvenv.xenovenvActivate the virtualenvsource./xenovenv/bin/activateInstallpip3installxenoponicsUsageSeexenoponics --helpfor usage information."I've been a plant lady since birth." -McCDouble21
Package: xentica
GPU-Accelerated Engine For Multi-Dimensional Cellular AutomataXenticais the core framework for theArtipixoids!project,
helping us to build GPU-accelerated models for multi-dimensional
cellular automata. Given pure Python definitions, Xentica generates
corresponding C code and runs it on GPU hardware.For more information, please refer to the officialXentica Documentation.Another point of interest isThe Conceptdocument, explaining the
main goals of the project and giving formal definitions to all features
of the Core Framework.The project is Open Source,contributionsare welcome.
Package: xenum
Xenum offers a simple alternative to Python 3 enums that’s
especially useful for (de)serialization.  When you would like
to model your enum values so that they survive jumps to and
from JSON, databases, and other sources cleanly as strings,
Xenum will allow you to do so extremely easily.InstallationInstallation is simple. With python3-pip, do the following:$ sudo pip install -e .Or, to install the latest version available on PyPI:$ sudo pip install xenumUsageJust create a basic class with attributes and annotate it with the@xenumattribute.  This will convert all of the class attributes
into Xenum instances and allow you to easily convert them to strings
viastr(MyEnum.A)and from strings viaMyEnum.by_name("MyEnum.A").Examplefrom xenum import xenum, ctor

@xenum
class Actions:
  INSERT = ctor('insert')
  UPDATE = ctor('update')
  DELETE = ctor('delete')

  def __init__(self, name):
     self.name = name

assert Actions.INSERT == Actions.by_name('Actions.INSERT')
assert Actions.INSERT().name == 'insert'Checkouttest.pyin the git repo for more usage examples.Change LogVersion 1.4: September 5th, 2016Add ‘xenum.sref()’ allowing enum values to be instances of the
@xenum annotated class, whos*argsis prepended with the
Xenum instance itself for self-reference.Version 1.3: September 4th, 2016Add ‘xenum.ctor()’ allowing enum values to be instances of the
@xenum annotated class.Made Xenum instances callable, returning the enum’s internal value.Version 1.2: September 4th, 2016Add ‘values()’ method to @xenum annotated classes for fetching
an ordered sequence of the Xenum entities created.Version 1.1: August 31st, 2016Made Xenum instances hashable, removed value() as a function.
Package: xenvman
Python client for xenvmanThis is a Python client library forxenvman.InstallationInstalling is a simple as running:pipinstallxenvmanUsageThe very first thing to do is to create a client:importxenvmancl=xenvman.Client()ifaddressargument is not provided, the defaulthttp://localhost:9876will be used. Also if shell environment variableXENV_API_SERVERis set,
it will be used instead.Once you have a client, you can create environment:env=cl.new_env(xenvman.InputEnv("python-test",description="Python test!",templates=[xenvman.Tpl("db/mongo")],))And that's it! Oncenew_env()returns, you have an environment which you can
start using in your integration tests.cont=env.get_container("db/mongo",0,"mongo")# Get the full mongo url with exposed portmongo_url="{}:{}".format(env.external_address(),cont.ports["27017"])Don't forget to terminate your env after you're done:env.terminate()
Package: xenzen
A Django UI for managingXenServerin the simplest possible way.Getting startedTo install XenZen run:$ git clone https://github.com/praekeltfoundation/xenzen.git
$ cd xenzen/
$ virtualenv ve
$ . ./ve/bin/activate
$ pip install -e .To start a development server listening on127.0.0.1:8000, with a SQLite database, run:$ export DJANGO_SETTINGS_MODULE=xenserver.testsettings
$ django-admin syncdb
$ django-admin collectstatic
$ django-admin runserverTo configure XenZen further, create the filelocal_settings.pycontaining extra Django settings. For example, to configure a PostgreSQL database:DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'xenzen',
        'USER': 'postgres',
        'PASSWORD': '',
        'HOST': 'localhost',
        'PORT': '',
    }
}
Package: xeo-simple-calc
xeo-simple-calcThis is my first python library. It is a simple calculator.How to useFirst, install the librarypipinstallxeo-simple-calcNext, import itfromxeosimplecalcimport*Then doc=Calc()Commandsc.add(num1,num2)Adds two numbers.c.subtract(num1,num2)Subtracts two numbers.c.multiply(num1,num2)Multiplies two numbers.c.divide(num1,num2)Divides two numbers. (returns a float)c.exponentiation(num,degree)Exponentiates a number to a certain degree. (Sorry the English is bad :-))c.square_root(num)Returns the square root of num. (returns a float)Change Log0.0.7 (07.07.2020)Moved all functions into a class.
Package: xepmts
A helper package for managing the PMT database used by the XENONnT Dark Matter Experiment.Basic Usageimportxepmts# If you are using a notebook:xepmts.notebook()# use v1 clientdb=xepmts.login("v1",token='YOUR-API-TOKEN')# or the v2 clientdb=xepmts.login("v2")# set the number of items to pull per pagedb.tpc.installs.items_per_page=25# get the next pagepage=db.tpc.installs.next_page()# iterate over pages:forpageindb.tpc.installs.pages():df=page.df# do something with data# select only top arraytop_array=db.tpc.installs.filter(array="top")# iterate over top array pagesforpageintop_array.pages():df=page.df# do something with dataquery=dict(pmt_index=4)# get the first page of results for this query as a list of dictionariesdocs=db.tpc.installs.find(query,max_results=25,page_number=1)# same as find, but returns a dataframedf=db.tpc.installs.find_df(query)# insert documents into the databasedocs=[{"pmt_index":1,"position_x":0,"position_y":0}]db.tpc.installs.insert_documents(docs)Free software: MITDocumentation:https://xepmts.readthedocs.io/FeaturesTODOCreditsThis package was created withCookiecutterand thebriggySmalls/cookiecutter-pypackageproject template.
Package: xer2csv
xer2csvThis package provides tools to convert XER files to CSV files.InstallationUse the package managerpipto installxer2csv.pip install xer2csvTestingtest.py file will parse all the ".xer" files from theinput_dirlocation and will parse them to theoutput_dirdirectory. For each table from XER file a separate CSV file will be created (within a subdirectory with the name of the original XER file).
usage:python test.py input_dir output_dirLicenseMIT
Package: xerial
xerial - Terminal Based Serial ConsoleGithub: github.com/nickpetty/xerialTravis-CI: travis-ci.org/nickpetty/xerial.svg?branch=masterxerial Copyright (C) 2016  Nicholas Petty, GPL V3
This program comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to redistribute it
under certain conditions; type `xerial -license' for details.Install:pip install xerialUsage:# Minimal Usage:
> xerial -p COM1  # default parameters are 9600 8/N/1


# Arguments:
-p <port>              # Connect to serial port.
-a <b/p/s>             # -a bytesize/parity/stopbits (default 8/N/1).
                       # Parity options 'N','E','O','M','S'.
-b <speed/baudrate>    # 9600, 115200, etc.
-CR                    # Carriage Return '\r'.
-LF                    # Linefeed (newline) '\n'.
-hw                    # Enable Hardware Handshake (rtscts).
-ls                    # List available ports.
-t <seconds>           # Timeout (in seconds).
-s <presetName>        # Save flags to preset file. Must be the last flag. Will not connect with flag.
                       # Usage: i.e., xerial -c /dev/tty.usbserial-A01293 -b 115200 -CR -s myPreset
-l <presetName>        # Load preset.  Usage: xerial -l myPreset
-lp                    # List presets in preset folder
                       # Optional: '-lp <presetname>' Lists parameters for given preset.
-h                     # This menu.
-log                   # Log all terminal activity to file in current working directory.
-license               # Display LicenseNotes:Type>qat anytime to exit serial terminal.Please submit all pull requests to thedevelopmentbranch.Platforms:OSXLinuxWindows
Package: xerosdk
xero-sdk-pyPython SDK to access Xero APIsRequirementsPython 3+RequestslibraryInstallationInstall Xero SDK usingpipas follows:pip install xerosdkUsageThis SDK requires OAuth2 authentication credentials such asclient ID,client secretandrefresh token.Create a connection using the XeroSDK class.fromxerosdkimportXeroSDKconnection=XeroSDK(base_url='<XERO_BASE_URL>',client_id='<YOUR CLIENT ID>',client_secret='<YOUR CLIENT SECRET>',refresh_token='<YOUR REFRESH TOKEN>')# tenant_id is required to make a call to any APItenant_id=connection.tenants.get_all()[0]['tenantId']connection.set_tenant_id(tenant_id)Access any of the API classes"""USAGE: <XeroSDK INSTANCE>.<API_NAME>.<API_METHOD>(<PARAMETERS>)"""# Get a list of all Invoicesresponse=connection.invoices.get_all()# Get a list of all Invoices using generatorforresponseininvoices.list_all_generator():print(response)# Get an Invoice by idresponse=connection.invoices.get_by_id(<invoice_id>)NOTE: Only Tenants, Invoices, Accounts, Contacts, Items and TrackingCategories
API classes are defined in this SDK.Integration TestsInstallpytestpackage using pip as follows:pip install pytestCreate a 'test_credentials.json' file at project root directory and enter Xero OAuth2 authentication credentials of
your Xero app.{"base_url":"<xero_base_url>","client_id":"<client_id>","client_secret":"<client_secret>","refresh_token":"<refresh_token>"}Run integration tests as follows:python -m pytest tests/integration
Package: xerox
Xeroxis a copy + paste module for python. It’s aim is simple: to be as incredibly simple as possible.Supported platforms are currently OS X, X11 (Linux, BSD, etc.), and Windows.If you can make it simpler, please fork.UsageUsage is as follows:xerox.copy(u'some string')And to paste:>>> xerox.paste()
u'some string'On Linux you can optionally also copy into the X selection clipboard for
middle-click-paste capability:xerox.copy(u'Some string', xsel=True)And you can choose to paste from the X selection rather than the system
clipboard:xerox.paste(xsel=True)And, that’s it.Command LineTo copy:$ xerox some stringor:$ echo some string | xeroxTo paste:>>> xerox
some stringInstallationTo install Xerox, simply:$ pip install xeroxNote: If you are installing xerox on Windows, you will also need to install thepywin32module.Legal StuffMIT License.(c) 2016 Kenneth Reitz.
Package: xer-reader
Xer-ReaderRead the contents of a Primavera P6 XER file using Python.Xer-Reader makes it easy to read, parse, and convert the data in a XER file to other formats.Refer to theOracle Documentationfor more information regarding how data is mapped to the XER format.Tested on XER files exported as versions 15.2 through 19.12.InstallWindows:pipinstallxer-readerLinux/Mac:pip3installxer-readerUsageImport theXerReaderclass fromxer_reader.fromxer_readerimportXerReaderCreate a new instance of anXerReaderobject by passing in the XER file as an argument.XerReadercan accept the file path represented as astror pathlibPathobject, or a Binary file received as a response from requests, Flask, FastAPI, etc...file=r"/path/to/file.xer"reader=XerReader(file)Attributesdata[str] -The contents of the XER file as a string.export_date[datetime] -The date the XER file was exported.export_user[str] -The P6 user who export the XER file.export_version[str] -The P6 verison used to export the XER file.file_name[str] -The name of the file without the '.xer' extension.Methodscheck_errors()->list[str]Checks the XER file for missing tables and orphan data, and returns the results as a list of errors.Missing tables can occur when an entry inTable 1points to an entry inTable 2butTable 2does not exist at all.Orphan data occurs when an entry inTable 1points to an entryTable 2but the entry inTable 2does not exist.delete_tables(*table_names: str)->strDelete a variable number of tables (table_names) from the XER file data and returns a new string (Does not modifyXerReader.dataattribute).In the following example the tables associated with User Defined Fields are removed from the XER file contents and stored in a new variablenew_xer_data, which can then be written to a new XER file:new_xer_data=reader.delete_tables("UDFTYPE","UDFVALUE")withopen("New_XER.xer","w",encoding=XerReader.CODEC)asnew_xer_file:new_xer_file.write(new_xer_data)get_table_names()->list[str]Returns a list of table names included in the XER file.get_table_str(table_name: str)->strReturns the tab seperated text for a specific table in the XER file.has_table(table_name: str)->boolReturn True if table (table_name) if found in the XER file.parse_tables()->dict[str, Table]Returns a dictionary with the table name as the key and aTableobject as the value.to_csv(file_directory: str | Path)->NoneGenerate a CSV file for each table in the XER file using 'tab' as the delimiter. CSV files will be created in the current working directory.Optional: Pass a string or Path object (file_directory) to speficy a folder to store the CSV files in.to_excel()->NoneGenerate an Excel (.xlsx) file with each table in the XER file on its own spreadsheet. The Excel file will be create in the
current working directory.to_json(*tables: str)->strGenerate a json compliant string representation of the tables in the XER file.Optional: Pass in specific table names to include in the json string.
Package: xersplitter
XER-SplitterA tool to handle the parsing of Oracles Primavera P6 .XER output files.
Convert your .XER files into seperate CSVs for parsing and transforming in other tools (eg. PowerBI for reporting)Features includeCSV or XLSX output of .XER filesGUI and CLI availableOptionally ignore problematic RISKTYPE & POBS tablesBasic metrics (Total tables & rows)Sample XERshereInstallationCommand lineUsepipto install XER-Splitter:pip install xersplitterThis puts xersplitter on the PATH, allowing you to invoke the gui or use the command line arguments.GUIAlternatively if you just want the gui, the latest build (windows .exe) can be foundhereor you can build the file yourself usingpyinstallerfrom the root folderpyinstaller xersplitter/Splitter.py --onefileUsageusage: xersplitter [-h] [-csv | -xlsx] [-i] [-o] [-cli] [-a]

A script to parse those pesky .xer files from Primavera P6

optional arguments:
  -h, --help           show this help message and exit
  -csv                 Comma seperated output
  -xlsx                Excel file output
  -i , --inputFile     The path to the input .xer file
  -o , --outputDir     The directory where the output files will be placed
  -cli, --suppressGui  Hide the GUI - opens by default
  -a, --allTables      Parse all tables - Skips possibly problematic RISKTYPE & POBS tables by defaultLicenseGPL v3.0
Package: xes
This project is on Github:https://github.com/jsumrall/xesThis is a simple library which has methods for generating XES files.
With this library you will be able to take your raw event data and
generate an XES file with a standard header. From the XES-Standard web page,
“XES is an XML-based standard for event logs. Its purpose is to provide a
generally-acknowledged format for the interchange of event log data between
tools and application domains. Its primary purpose is for process mining,
i.e. the analysis of operational processes based on their event logs.”As usual, examples are the best way to see what this does.Example usage looks like this:#!/usr/bin/env python

import xes

traces = [
    [
        {"concept:name" : "Register", "org:resource" : "Bob"},
        {"concept:name" : "Negotiate", "org:resource" : "Sally"},
        {"concept:name" : "Negotiate", "org:resource" : "Sally"},
        {"concept:name" : "Sign", "org:resource" : "Dan"},
        {"concept:name" : "Sendoff", "org:resource" : "Mary"}
    ],
    [
        {"concept:name" : "Register", "org:resource" : "Bob"},
        {"concept:name" : "Negotiate", "org:resource" : "Sally"},
        {"concept:name" : "Sign", "org:resource" : "Dan"},
        {"concept:name" : "Sendoff", "org:resource" : "Mary"}
    ],
    [
        {"concept:name" : "Register", "org:resource" : "Bob"},
        {"concept:name" : "Negotiate", "org:resource" : "Sally"},
        {"concept:name" : "Sign", "org:resource" : "Dan"},
        {"concept:name" : "Negotiate", "org:resource" : "Sally"},
        {"concept:name" : "Sendoff", "org:resource" : "Mary"}
    ],
    [
        {"concept:name" : "Register", "org:resource" : "Bob"},
        {"concept:name" : "Sign", "org:resource" : "Dan"},
        {"concept:name" : "Sendoff", "org:resource" : "Mary"}
    ]
]


log = xes.Log()
for trace in traces:
    t = xes.Trace()
    for event in trace:
        e = xes.Event()
        e.attributes = [
            xes.Attribute(type="string", key="concept:name", value=event["concept:name"]),
            xes.Attribute(type="string", key="org:resource", value=event["org:resource"])
        ]
        t.add_event(e)
    log.add_trace(t)
log.classifiers = [
    xes.Classifier(name="org:resource",keys="org:resource"),
    xes.Classifier(name="concept:name",keys="concept:name")
]

open("example.xes", "w").write(str(log))