Saravanan666/pypi-org huggingface dataset:
Package: compose-viz
Explore Usage »Report Bug·Request FeatureTable of ContentsAbout The ProjectGetting StartedPrerequisitiesInstallationExampleUsageOptionsRoadmapContributingLicenseContactAbout The Projectcompose-vizis a compose file visualization tool that followscompose-specand allows you to gernerate graph in several formats.If you are looking for a compose file vizualization tool, and you are using one of thecompose-specimplementations (e.g.docker-compose/podman-compose), thencompose-vizis a great choice for you.(back to top)Getting StartedPrerequisitiesGraphvizYou need to installGraphvizto generate graphs.InstallationUsingpippip install compose-vizUsing.whlSeereleases.Docker ImageSeewst24365888/compose-viz.ExampleThis example yml is fromdocker compose beginner tutorial.cdexamples/voting-app/# using python scriptcpv-msvgdocker-compose.yml# using docker imagedockerrun--rm-it-v$(pwd):/inwst24365888/compose-viz-msvgdocker-compose.yml# using docker image in powershelldockerrun--rm-it-v${pwd}:/inwst24365888/compose-viz-msvgdocker-compose.ymlAnd this is what the result looks like:Check out the resulthere.Usagecpv [OPTIONS] INPUT_PATHOptionsOptionDescription-o, --output-filename FILENAMEOutput filename for the generated visualization file. [default: compose-viz]-m, --format FORMATOutput format for the generated visualization file. Seesupported formats. [default: png]-r, --root-service SERVICE_NAMERoot of the service tree (convenient for large compose yamls)-v, --versionShow the version of compose-viz.--helpShow help and exit.(back to top)RoadmapSupport more vizualization components.See theopen issuesfor a full list of proposed features (and known issues).(back to top)ContributingContributions are what make the open source community such an amazing place to
learn, inspire, and create. Any contributions you make aregreatly
appreciated.If you have a suggestion that would make this better, please fork the repo and
create a pull request. You can also simply open an issue with the tag
"enhancement". Don't forget to give the project a star! Thanks again!Fork the ProjectCreate your Feature Branch (git checkout -b feat/amazing-feature)Commit your Changes withConventional CommitsPush to the Branch (git push origin feat/amazing-feature)Open a Pull Request(back to top)LicenseDistributed under the MIT License. SeeLICENSEfor more information.(back to top)ContactAuthorHSING-HAN, WU (Xyphuz)Mail me:xyphuzwu@gmail.comAbout me:https://www.xyphuz.comGitHub:https://github.com/wst24365888Project Linkhttps://github.com/compose-viz/compose-viz(back to top)
Package: compose-watcher
compose-watcherCli that restarts you docker compose services when a file inside one of its volumes changes.Useful for faster developement with containers that expose behaviour based on mounted files.Example usagegraphql api restart when schema file changesgraphql api mocks based on schema file (like this one)Every container that generates code and exposes a server based on a config fileNodejs container restarts when the src folder changes, recompiling with tscMongokerestarts when config schema changesInstallpip3installcompose-watcher# then you can watch for changescompose-watcher-fdocker-compose.ymlUsageUse the directories you want to track as service volumes.Also consider usinginit: truein the compose service definition for faster killing of processes.To not stop thedocker-composecommands on other terminals there should be always a running container (this is a strange fact about docker-compose).version: '3'

services:
  api:
    build: .
    command: sh -c 'tsc --incremental && node index.js'
    volumes:
      - ./src:/srcThen executecompose-watcherto watch changes.compose-watcher-fdocker-compose.yml--timeout5TODO add extension filterHow it worksAfter running thecompose-watchercommand all the volumes mounted on every service are tracked for change, when a change happens the service where the volume is mounted is restarted toghether with the services in thedepends_onfiled. Then the other services that have the restarted service as a dependency independs_onare restarted too.
Package: composio-llamaindex
Composio <> Llama Indxex
Use Composio to get an array of tools with your llamaindex agent.UsageInside your llamaindex codebase:from composio_llama import ComposioToolset
toolset = ComposioToolset(<token>)
agent = OpenAIAgent.from_tools(toolset.to_tool_list(), llm=llm, verbose=True)
...
Package: composipy
ComposipyWhat it iscomposipyis a python library to calculate composite plates using the classical laminate theory. This library is designed to be simple, userfriendly and helpfull.Composipy is able to perform buckling calculation considering different boundary conditions and in-plane load applications. SeeExamples.How to installDirectly From PYPIpipinstallcomposipyBuilt from sourcepythonsetup.pyinstallDocumentationComposipy documentationExamplesCode ReferencesQuick startCreate the Material Properties.>>>fromcomposipyimportOrthotropicMaterial>>>>>>E1=60800>>>E2=58250>>>v12=0.07>>>G12=4550>>>t=0.21>>>>>>mat_1=OrthotropicMaterial(E1,E2,v12,G12,t)SeeOrthotropicMaterialfor reference.Define the Laminate.>>>fromcomposipyimportLaminateProperty>>>stacking=[-45,45,90,0,0,0,0,90,45,-45]>>>laminate1=LaminateProperty(stacking,mat_1)SeeLaminatePropertyfor reference.Calculate Stiffnnes Matrix and Lamination Parameters>>>print(laminate1.ABD)# prints the ABD matrix as a np.ndarray>>>print(laminate1.xiA)# prints lamination parameters of extension as a np.ndarray>>>print(laminate1.xiD)# prints lamination parameters of bending as a np.ndarrayCreate a Plate Structure.>>>fromcomposipyimportPlateStructure>>>>>>constraints={---'x0':['TX','TY','TZ','RX','RY','RZ'],---'xa':['TX','TY','TZ','RX','RY','RZ'],---'y0':['TX','TY','TZ','RX','RY','RZ'],---'yb':['TX','TY','TZ','RX','RY','RZ']---}>>>panel=PlateStructure(laminate1,360,360,m=10,n=10,Nxx=-1,constraints=constraints)SeePlateStructurefor reference.Calculate Buckling>>>print(panel.buckling_analysis())# solve the eigenvalue problem.Plot Buckling shape mode>>>print(panel.plot_eigenvalue())Theoretical ReferencesThe implementation of composipy is based on the following referencesMechanics Of Composite Materials by Robert M. JonesCastro S.G.P., Donadon M.V. Assembly of semi-analytical models to address linear buckling and vibration of stiffened composite panels with debonding defect. Compos. Struct., 160 (2017), pp. 232-247,
Package: composites
Github Actions status:Coverage status:Methods to calculate composite plate propertiesHigh-performance module to calculate properties of laminated composite
materials. Usually, this module is used to calculate:A, B, D, E plane-stress stiffness matrices for platesA, B, D, for classical plate theory (CLT, or CLPT)E for first-order shear deformation theory (FSDT)Material invariants, trace-normalized or notLamination parameters based on material invariantsStiffness matrices (ABDE) based on lamination parametersCiting this repositoryCastro, S. G. P. Methods to calculate composite plate properties (Version
0.6.5) [Computer software]. 2024.https://doi.org/10.5281/zenodo.2871782Bibtex :@misc{composites2024,
    author = {Castro, Saullo G. P.},
    doi = {10.5281/zenodo.2871782},
    title = {{Methods to calculate composite plate properties (Version 0.6.5) [Computer software]. 2024}}
    }DocumentationThe documentation is available on:https://saullocastro.github.io/composites.Historyversion 0.1.0, from sub-module of compmech 0.7.2version 0.2.2, from sub-module of meshless 0.1.19version 0.2.3 onwards: independent of previous packagesversion 0.3.0 onwards: with fast Cython version, not compatible with previous versionsversion 0.4.0 onwards: fast Cython and cimportable by other packages, full
compatibility with finite element mass matrices of plates and shells,
supporting laminated plates with materials of different densitiesversion 0.5.4 onwards: verified lamination parameters, analytical gradients
of Aij, Bij, Dij with respect to lamination parameters, supportting MAC-OSversion 0.5.17 onwards: installing with pipversion 0.6.0 onwards: cibuildwheel to distribute for LinuxLicenseDistrubuted under the 3-Clause BSD license
(https://raw.github.com/saullocastro/composites/master/LICENSE).Contact:S.G.P.Castro@tudelft.nl.
Package: composite-ufjc-scission
The Python package for the composite uFJC model with scission.InstallationThis package can be installed usingpipvia thePython Package Index(PyPI),pip install composite-ufjc-scissionAlternatively, a branch can be directly installed usingpip install git+https://github.com/jasonmulderrig/composite-uFJC-scission.git@<branch-name>or after cloning a branch, moving to the main project directory (where the setup and configuration files are located), and executingpip install-e.for an editable installation orpip install .for a standard installation.InformationLicenseReleasesRepositoryCitationJason Mulderrig, Brandon Talamini, and Nikolaos Bouklas,composite-ufjc-scission: the Python package for the composite uFJC model with scission,Zenodo (2022).Jason Mulderrig, Brandon Talamini, and Nikolaos Bouklas, A statistical mechanics framework for polymer chain scission, based on the concepts of distorted bond potential and asymptotic matching,Journal of the Mechanics and Physics of Solids 174, 105244 (2023).
Package: composite-ufjc-scission-ufl-fenics
The Python package for the composite uFJC model with scission implemented in the Unified Form Language (UFL) for FEniCS. This repository is dependent upon thecomposite-uFJC-scissionPython package.InstallationThis package can be installed usingpipvia thePython Package Index(PyPI),pip install composite-ufjc-scission-ufl-fenicsAlternatively, a branch can be directly installed usingpip install git+https://github.com/jasonmulderrig/composite-uFJC-scission-UFL-FEniCS.git@<branch-name>or after cloning a branch, moving to the main project directory (where the setup and configuration files are located), and executingpip install-e.for an editable installation orpip install .for a standard installation.InformationLicenseReleasesRepositoryCitationJason Mulderrig, Brandon Talamini, and Nikolaos Bouklas,composite-ufjc-scission-ufl-fenics: the Python package for the composite uFJC model with scission implemented in the Unified Form Language (UFL) in FEniCS,Zenodo (2023).Jason Mulderrig, Brandon Talamini, and Nikolaos Bouklas,composite-ufjc-scission: the Python package for the composite uFJC model with scission,Zenodo (2022).Jason Mulderrig, Brandon Talamini, and Nikolaos Bouklas, A statistical mechanics framework for polymer chain scission, based on the concepts of distorted bond potential and asymptotic matching,Journal of the Mechanics and Physics of Solids 174, 105244 (2023).
Package: composition
Hi mature software developer!You have decided inheritance isn’t your cup of tea?Well have we got the thing for you!This module does one thing:importcompositionclassSuperclass(object):passclassThisWillGoBoom(Superclass):passEnjoy. This is mature software, put it in production, and let it drive your
car.Installation$ pip install compositionof course. Python 3.6+ only though, sorry kids.Wait Wat?https://en.wikipedia.org/wiki/Composition_over_inheritance
Package: compositional-attention
Compositional AttentionThis repository is an implementation ofCompositional Attention: Disentangling Search and Retrievalby MILA. Revisiting standard Multi-head attention through the lens of multiple parallel and independent search and retrieval mechanisms, this leads to static pairings between searches and retrievals, often leading to redundancy of parameters. They reframe the "heads" of multi-head attention as "searches", and once the multi-headed/searched values are aggregated, there is an extra retrieval step (using attention) off the searched results. The experiments establish this as an easy drop-in replacement for Multi-head attention.InstallationRun the following to install:pipinstallcompositional-attentionDevelopingcompositional-attentionTo installcompositional-attention, along with tools you need to develop and test, run the following in your virtualenv:gitclonehttps://github.com/Rishit-dagli/compositional-attention.git# or clone your own forkcdcompositional-attention
pipinstall-e.[dev]Usageimporttensorflowastffromcompositional_attentionimportCompositionalAttentionattn=CompositionalAttention(dim=1024,# input dimensiondim_head=64,# dimension per attention 'head' - head is now either search or retrievalnum_searches=8,# number of searchesnum_retrievals=2,# number of retrievalsdropout=0.1,# dropout of attention of search and retrieval)tokens=tf.random.uniform([1,512,1024])# tokensmask=tf.ones([1,512],dtype=tf.dtypes.bool)# maskout=attn(tokens,mask=mask)# (1, 512, 1024)Want to Contribute 🙋‍♂️?Awesome! If you want to contribute to this project, you're always welcome! SeeContributing Guidelines. You can also take a look atopen issuesfor getting more information about current or upcoming tasks.Want to discuss? 💬Have any questions, doubts or want to present your opinions, views? You're always welcome. You canstart discussions.CitationsMittal, Sarthak, et al. ‘Compositional Attention: Disentangling Search and Retrieval’. ArXiv:2110.09419 [Cs], Feb. 2022. arXiv.org, http://arxiv.org/abs/2110.09419.OfficialPyTorch implmentationand Phil Wang'sPyTorch implmenetation.
Package: composition_based_feature_vector
CBFV PackageTool to quickly create a composition-based feature vectors from materials datafiles.InstallationThe source code is currently hosted on GitHub at:https://github.com/kaaiian/CBFVBinary installers for the latest released version are available at thePython Package Index (PyPI)# PyPI
pip install CBFVMaking the composition-based feature vectorThe CBFV package assumes your data is stored in a pandas dataframe of the following structure:formulatargetTc1V1248.539Cu1Dy166.8444Cd3N291.5034To featurize this data, thegenerate_featuresfunction can be called as follows:from CBFV import composition
X, y, formulae, skipped = composition.generate_features(df)Extended FunctionalityThe featurization scheme can be adjusted by calling the theelem_propparameter. The following featurization schemes are included within CBFV:jarvismagpiemat2vecoliynyk (default)onehotrandom_200Duplicate formula handeling is controlled by thedrop_duplicatesparameter. It is set toFalseby default to preserve datapoints containing variation outside of their formula. For example, heat capacity measurements performed for the same material at different temperatures.Theextend_featuresparameter is used to specify whether columns outside of['formula', 'target']should be considered during featurization. It is set toFalseby default to exclude nuisance information from consideration. Settingextend_features=Truewould allow additional information (i.e.['temperature', 'pressure']) to be preserved.Thesum_featparameter specifies whether to calculate the sum features when generating the CBFVs for the chemical formulae. It is set toFalseby default.Callinggenerate_featureswith these parameters can be implemented as follows:formulatargettempTc1V1248.539373Tc1V166.8444473Cd3N291.5034273from CBFV import composition
X, y, formulae, skipped = composition.generate_features(df,
                                                        elem_prop='magpie',
                                                        drop_duplicates=False,
                                                        extend_features=True,
                                                        sum_feat=True)
Package: composition-entity-linker
Composition Entity Linker (under development)This is a tool for linking classical music record & track to the corresponding composition / movement, useful in cleaning up metadata in classical music datasets. Inputs are referenced through corpus crawled fromhttps://imslp.org/wiki/Main_Page.Installpip install composition-entity-linkerUsagefrom composition_entity_linker import CELlinker, Track
linker = CELlinker()1. Query the composition from track name:track = Track("Violin Sonata in A Major, Op. 162, D. 574 ""Grand Duo"": III. Andantino (Live)", composer="Franz Schubert")
result = linker.query(track)
"""
result: {
    "found_flag": True,
    "composition": "Violin Sonata in A major, D.574"
    "movement": "Andantino"
}
"""2. Compare if the two tracks are refering to the same composition:track1 = Track("Prelude and Fugue No. 2 in C Minor BWV 847", composer="Johann Sebastian Bach")
track2 = Track("Prelude & Fugue In C Minor (Well-Tempered Clavier, Book I, No. 2), BWV 847", composer="J.S. Bach")
linker.compare(track1, track2)
# return: True


track3 = Track("Das Wohltemperierte Klavier: Book 1, BWV 846-869: Fugue in C minor BWV 847", composer="Иоганн Себастьян Бах")
linker.compare(track1, track3)
# return: TrueTrack infoAlthough only the title is required, inputing composer name will improve matching accuracy and speed.Track(title: str, 
    duration: float in ms,
    composer: str)
Package: compositions-coda
CompositionsAn extensive package for compositional data analysis. The major implementations are presented as follows.Various transformation functions along with their inverses have been implemented to aid compositional data analysis (CoDA).Installation::pip install compositions-codaUsageTransformations:.. role::  raw-html(raw)
:format: htmlCentered Log Ratio (clr)transform.clrfor forward transformation S :sup:D:raw-html:&rarr;R :sup:D.transform.clrInvfor inverse transform R :sup:D:raw-html:&rarr;S :sup:D.Isometric Log Ratio (ilr)transform.ilrfor forward transformation S :sup:D:raw-html:&rarr;R :sup:D-1.transform.ilrInvfor inverse transform R :sup:D-1:raw-html:&rarr;S :sup:D.Additive Log Ratio (alr)transform.alrfor forward transform S :sup:D:raw-html:&rarr;R :sup:D-1.transform.alrInvfor inverse transform R :sup:D-1:raw-html:&rarr;S :sup:D.
Package: compositionspace
CompositionSpaceCompositionSpace is a python library for analysis of APT data.InstallationInstallation using pipCompositionspace can be installed using:pip install compositionspaceInstallation usingCondaIt isstronglyrecommended to install and usecalphywithin a conda environment. To see how you can install conda seehere.Once a conda distribution is available, the following steps will help set up an environment to usecompositionspace. First step is to clone the repository.git clone https://github.com/eisenforschung/CompositionSpace.gitAfter cloning, an environment can be created from the included file-cd CompositionSpace
conda env create -f environment.ymlActivate the environment,conda activate compspacethen, installcompositionspaceusing,python setup.py installThe environment is now set up to run calphy.ExamplesFor an example of the complete workflow usingcompositionspace, seeexample/full_workflow.ipynb.The provided dataset is a small one for testing purposes, which is also accessible here:Ceguerra, AV (2021) Supplementary material: APT test cases.
Available athttp://dx.doi.org/10.25833/3ge0-y420DocumentationDocumentation is availablehere.
Package: composition-stats
Python module for compositional data analysis. Install with pip:pip install composition_statsThe following functions are provided:closurePerforms closure to ensure that all
elements add up to 1.multiplicative_replacementReplace all zeros with small non-zero
aluesperturbPerforms the perturbation operation.perturb_invPerforms the inverse perturbation
operation.powerPerforms the power operation.innerCalculates the Aitchson inner product.clrPerforms centre log ratio
transformation.clr_invPerforms inverse centre log ratio
transformation.ilrPerforms isometric log ratio
transformation.ilr_invPerforms inverse isometric log ratio
transform.alrPerforms additive log ratio
transformation.alr_invPerforms inverse additive log ratio
transform.centerComputes the geometric average of data.centralizeCenter data around its geometric
average.sbp_basisBuilds an orthogonal basis from a
sequential binary partition (SBP).Please see thedocumentationfor details and a complete function reference.This is a fork of the essential compositional data functions of theskbio.stats.compositionmodule fromscikit-bio.  However, for reasons of
performance, the functions in this module expect inputs where compositions
already sum to unity, and do not callclosure()on inputs internally.
Package: compotime
compotimecompotime is a library for forecasting compositional time series. At the moment, it provides an implementation of the models described in the paper"Forecasting compositional time series: A state space approach"(Snyder, R.D. et al, 2017). It is constantly tested to be compatible with the major machine learning and statistics libraries within the Python ecosystem.Quick installcompotime is currently available for python 3.9, 3.10 and 3.11. It can be installed from PyPI:pipinstallcompotimeBasic usageThis example uses adapted data on the popularity of programming languages (PYPL).importpandasaspdfromcompotimeimportLocalTrendForecaster,preprocessURL="https://raw.githubusercontent.com/mateuja/compotime/main/examples/data/proglangpop_sample.csv"time_series=pd.read_csv(URL,converters={"Date":pd.Period},index_col="Date").pipe(preprocess.treat_small,1e-3)model=LocalTrendForecaster().fit(time_series)model.predict(horizon=10)For more details, see theDocumentation.
Package: compound-eye-tools
Compound Eye ToolsThis library automatically counts and measures the ommatidia of compound eyes from images.On Counting OmmatidiaMy graduate mentor once challenged me to count the ommatidia of vinegar flies (a.k.a. fruit flies,Drosophila melanogaster). I quickly learned that they have two compound eyes, each composed of about 1000 light collecting facets called ommatidia. I learned this as I counted the ommatidia of over 100 flies, culminating in over90,000ommatidia (anda publication)!Over 90,000 ommatidia from more than 100 flies that I counted by hand. My notes are in white. The geometric arrangement allowed me to count large triangles of ommaitida instead of individuals. Still, a lot of counting.Many have braved this greuling task of counting ommatidia because, among other reasons, compound eyes are the most common image forming structures on Earth. Compound eyes are used by arthropods, which occupy nearly every ecological niche and represent roughly 80% of described animal species (the massive blue slice of the pie of life below). Compound eyes vary substantially in shape and size, having adapted to the gamut of selective pressures. So, to understand how vision works, develops, and evolves, we must study compound eyes.The Pie of Life: notice the large blue pie representing the arthropods (pronounced "insects")Plus, as opposed to our camera-type eyes, many of the structures limiting the visual performance of compound eyes can be measured in direct external images. The number and size of ommatidia set physical limitations on what a compound eye can see. Each one collects a pixel of the image captured by the retina and sits immediately adjacent to the next ommatidium, separated by screening pigment (see below). The angle separating neighboring ommatidia, called the interommatidial angle, determines the smallest resolvable detail just like the inter-receptor angle of our own camera-type eyes. The size of the ommatidial aperture limits the amount of light available for absorption so that large ommatidia offer greater sensitivity to low light levels. Counting and measuring ommatidia tells us a great deal about the spatial resolution and light sensitivity of many arthropods.The camera-type eye can have a higher spatial resolution because one lens serves the whole retina. For a compound eye to acheive the same resolution as our eyes, for instance, it would need to be at least 1 meter in diameter and composed of millions of ommatidia!Wouldn't it be nice if a program could count these ommatidia automatically? Humanity has developed programs that can beat grand champions in chess or generate fake videos of past presidents. If computers can drive cars and recognize faces, shouldn't they be able to detect ommatidia? Introducing theOmmatidia Detecting Algorithm (ODA)General Pipeline of the ODATo get a feel for how the ODA works, try outthis interactive iPython notebook hosted on Binder.]InstallationSimple RecipesIndividual ImageImage StackCT Stack (ODA-3D)